Fix ArrayNodeTest and ObjectNodeTest to use proper NodeKind byte + pa…

…dding format

- Add NodeKind byte before size prefix
- Use 3 bytes padding (total 8 bytes with NodeKind)
- Skip NodeKind byte before deserialize
- Tests now pass with proper 8-byte alignment

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/DatabaseModule_DatabaseSessionsFactory.java

@@ -0,0 +1,33 @@
+package io.sirix.access;
+
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import io.sirix.api.Database;
+import javax.annotation.processing.Generated;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class DatabaseModule_DatabaseSessionsFactory implements Factory<PathBasedPool<Database<?>>> {
+  @Override
+  public PathBasedPool<Database<?>> get() {
+    return databaseSessions();
+  }
+
+  public static DatabaseModule_DatabaseSessionsFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static PathBasedPool<Database<?>> databaseSessions() {
+    return Preconditions.checkNotNullFromProvides(DatabaseModule.databaseSessions());
+  }
+
+  private static final class InstanceHolder {
+    private static final DatabaseModule_DatabaseSessionsFactory INSTANCE = new DatabaseModule_DatabaseSessionsFactory();
+  }
+}

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/DatabaseModule_ResourceManagersFactory.java

@@ -0,0 +1,33 @@
+package io.sirix.access;
+
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import io.sirix.api.ResourceSession;
+import javax.annotation.processing.Generated;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class DatabaseModule_ResourceManagersFactory implements Factory<PathBasedPool<ResourceSession<?, ?>>> {
+  @Override
+  public PathBasedPool<ResourceSession<?, ?>> get() {
+    return resourceManagers();
+  }
+
+  public static DatabaseModule_ResourceManagersFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static PathBasedPool<ResourceSession<?, ?>> resourceManagers() {
+    return Preconditions.checkNotNullFromProvides(DatabaseModule.resourceManagers());
+  }
+
+  private static final class InstanceHolder {
+    private static final DatabaseModule_ResourceManagersFactory INSTANCE = new DatabaseModule_ResourceManagersFactory();
+  }
+}

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/LocalDatabaseModule_DatabaseNameFactory.java

@@ -0,0 +1,37 @@
+package io.sirix.access;
+
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class LocalDatabaseModule_DatabaseNameFactory implements Factory<String> {
+  private final Provider<DatabaseConfiguration> configurationProvider;
+
+  public LocalDatabaseModule_DatabaseNameFactory(
+      Provider<DatabaseConfiguration> configurationProvider) {
+    this.configurationProvider = configurationProvider;
+  }
+
+  @Override
+  public String get() {
+    return databaseName(configurationProvider.get());
+  }
+
+  public static LocalDatabaseModule_DatabaseNameFactory create(
+      Provider<DatabaseConfiguration> configurationProvider) {
+    return new LocalDatabaseModule_DatabaseNameFactory(configurationProvider);
+  }
+
+  public static String databaseName(DatabaseConfiguration configuration) {
+    return Preconditions.checkNotNullFromProvides(LocalDatabaseModule.databaseName(configuration));
+  }
+}

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/LocalDatabaseModule_DatabaseTypeFactory.java

@@ -0,0 +1,37 @@
+package io.sirix.access;
+
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class LocalDatabaseModule_DatabaseTypeFactory implements Factory<DatabaseType> {
+  private final Provider<DatabaseConfiguration> configurationProvider;
+
+  public LocalDatabaseModule_DatabaseTypeFactory(
+      Provider<DatabaseConfiguration> configurationProvider) {
+    this.configurationProvider = configurationProvider;
+  }
+
+  @Override
+  public DatabaseType get() {
+    return databaseType(configurationProvider.get());
+  }
+
+  public static LocalDatabaseModule_DatabaseTypeFactory create(
+      Provider<DatabaseConfiguration> configurationProvider) {
+    return new LocalDatabaseModule_DatabaseTypeFactory(configurationProvider);
+  }
+
+  public static DatabaseType databaseType(DatabaseConfiguration configuration) {
+    return Preconditions.checkNotNullFromProvides(LocalDatabaseModule.databaseType(configuration));
+  }
+}

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/ResourceSessionModule_IoStorageFactory.java

@@ -0,0 +1,38 @@
+package io.sirix.access;
+
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import io.sirix.io.IOStorage;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class ResourceSessionModule_IoStorageFactory implements Factory<IOStorage> {
+  private final Provider<ResourceConfiguration> resourceConfigurationProvider;
+
+  public ResourceSessionModule_IoStorageFactory(
+      Provider<ResourceConfiguration> resourceConfigurationProvider) {
+    this.resourceConfigurationProvider = resourceConfigurationProvider;
+  }
+
+  @Override
+  public IOStorage get() {
+    return ioStorage(resourceConfigurationProvider.get());
+  }
+
+  public static ResourceSessionModule_IoStorageFactory create(
+      Provider<ResourceConfiguration> resourceConfigurationProvider) {
+    return new ResourceSessionModule_IoStorageFactory(resourceConfigurationProvider);
+  }
+
+  public static IOStorage ioStorage(ResourceConfiguration resourceConfiguration) {
+    return Preconditions.checkNotNullFromProvides(ResourceSessionModule.ioStorage(resourceConfiguration));
+  }
+}

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/ResourceSessionModule_RootPageFactory.java

@@ -0,0 +1,37 @@
+package io.sirix.access;
+
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import io.sirix.io.IOStorage;
+import io.sirix.page.UberPage;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class ResourceSessionModule_RootPageFactory implements Factory<UberPage> {
+  private final Provider<IOStorage> storageProvider;
+
+  public ResourceSessionModule_RootPageFactory(Provider<IOStorage> storageProvider) {
+    this.storageProvider = storageProvider;
+  }
+
+  @Override
+  public UberPage get() {
+    return rootPage(storageProvider.get());
+  }
+
+  public static ResourceSessionModule_RootPageFactory create(Provider<IOStorage> storageProvider) {
+    return new ResourceSessionModule_RootPageFactory(storageProvider);
+  }
+
+  public static UberPage rootPage(IOStorage storage) {
+    return Preconditions.checkNotNullFromProvides(ResourceSessionModule.rootPage(storage));
+  }
+}

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/ResourceSessionModule_WriteLockFactory.java

@@ -0,0 +1,43 @@
+package io.sirix.access;
+
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import java.util.concurrent.Semaphore;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class ResourceSessionModule_WriteLockFactory implements Factory<Semaphore> {
+  private final Provider<WriteLocksRegistry> registryProvider;
+
+  private final Provider<ResourceConfiguration> resourceConfigurationProvider;
+
+  public ResourceSessionModule_WriteLockFactory(Provider<WriteLocksRegistry> registryProvider,
+      Provider<ResourceConfiguration> resourceConfigurationProvider) {
+    this.registryProvider = registryProvider;
+    this.resourceConfigurationProvider = resourceConfigurationProvider;
+  }
+
+  @Override
+  public Semaphore get() {
+    return writeLock(registryProvider.get(), resourceConfigurationProvider.get());
+  }
+
+  public static ResourceSessionModule_WriteLockFactory create(
+      Provider<WriteLocksRegistry> registryProvider,
+      Provider<ResourceConfiguration> resourceConfigurationProvider) {
+    return new ResourceSessionModule_WriteLockFactory(registryProvider, resourceConfigurationProvider);
+  }
+
+  public static Semaphore writeLock(WriteLocksRegistry registry,
+      ResourceConfiguration resourceConfiguration) {
+    return Preconditions.checkNotNullFromProvides(ResourceSessionModule.writeLock(registry, resourceConfiguration));
+  }
+}

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/WriteLocksRegistry_Factory.java

@@ -0,0 +1,31 @@
+package io.sirix.access;
+
+import dagger.internal.Factory;
+import javax.annotation.processing.Generated;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class WriteLocksRegistry_Factory implements Factory<WriteLocksRegistry> {
+  @Override
+  public WriteLocksRegistry get() {
+    return newInstance();
+  }
+
+  public static WriteLocksRegistry_Factory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static WriteLocksRegistry newInstance() {
+    return new WriteLocksRegistry();
+  }
+
+  private static final class InstanceHolder {
+    private static final WriteLocksRegistry_Factory INSTANCE = new WriteLocksRegistry_Factory();
+  }
+}

bundles/sirix-core/bin/generated-sources/annotations/io/sirix/access/json/JsonLocalDatabaseModule_JsonDatabaseFactory.java

@@ -0,0 +1,73 @@
+package io.sirix.access.json;
+
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import io.sirix.access.DatabaseConfiguration;
+import io.sirix.access.PathBasedPool;
+import io.sirix.access.ResourceStore;
+import io.sirix.access.WriteLocksRegistry;
+import io.sirix.api.Database;
+import io.sirix.api.ResourceSession;
+import io.sirix.api.TransactionManager;
+import io.sirix.api.json.JsonResourceSession;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes"
+})
+public final class JsonLocalDatabaseModule_JsonDatabaseFactory implements Factory<Database<JsonResourceSession>> {
+  private final Provider<TransactionManager> transactionManagerProvider;
+
+  private final Provider<DatabaseConfiguration> dbConfigProvider;
+
+  private final Provider<PathBasedPool<Database<?>>> sessionsProvider;
+
+  private final Provider<ResourceStore<JsonResourceSession>> resourceStoreProvider;
+
+  private final Provider<WriteLocksRegistry> writeLocksProvider;
+
+  private final Provider<PathBasedPool<ResourceSession<?, ?>>> resourceManagersProvider;
+
+  public JsonLocalDatabaseModule_JsonDatabaseFactory(
+      Provider<TransactionManager> transactionManagerProvider,
+      Provider<DatabaseConfiguration> dbConfigProvider,
+      Provider<PathBasedPool<Database<?>>> sessionsProvider,
+      Provider<ResourceStore<JsonResourceSession>> resourceStoreProvider,
+      Provider<WriteLocksRegistry> writeLocksProvider,
+      Provider<PathBasedPool<ResourceSession<?, ?>>> resourceManagersProvider) {
+    this.transactionManagerProvider = transactionManagerProvider;
+    this.dbConfigProvider = dbConfigProvider;
+    this.sessionsProvider = sessionsProvider;
+    this.resourceStoreProvider = resourceStoreProvider;
+    this.writeLocksProvider = writeLocksProvider;
+    this.resourceManagersProvider = resourceManagersProvider;
+  }
+
+  @Override
+  public Database<JsonResourceSession> get() {
+    return jsonDatabase(transactionManagerProvider.get(), dbConfigProvider.get(), sessionsProvider.get(), resourceStoreProvider.get(), writeLocksProvider.get(), resourceManagersProvider.get());
+  }
+
+  public static JsonLocalDatabaseModule_JsonDatabaseFactory create(
+      Provider<TransactionManager> transactionManagerProvider,
+      Provider<DatabaseConfiguration> dbConfigProvider,
+      Provider<PathBasedPool<Database<?>>> sessionsProvider,
+      Provider<ResourceStore<JsonResourceSession>> resourceStoreProvider,
+      Provider<WriteLocksRegistry> writeLocksProvider,
+      Provider<PathBasedPool<ResourceSession<?, ?>>> resourceManagersProvider) {
+    return new JsonLocalDatabaseModule_JsonDatabaseFactory(transactionManagerProvider, dbConfigProvider, sessionsProvider, resourceStoreProvider, writeLocksProvider, resourceManagersProvider);
+  }
+
+  public static Database<JsonResourceSession> jsonDatabase(TransactionManager transactionManager,
+      DatabaseConfiguration dbConfig, PathBasedPool<Database<?>> sessions,
+      ResourceStore<JsonResourceSession> resourceStore, WriteLocksRegistry writeLocks,
+      PathBasedPool<ResourceSession<?, ?>> resourceManagers) {
+    return Preconditions.checkNotNullFromProvides(JsonLocalDatabaseModule.jsonDatabase(transactionManager, dbConfig, sessions, resourceStore, writeLocks, resourceManagers));
+  }
+}