VersionedMapStoreFactoryBuilder.java is introduced, all tests are updated.

VersionedMapStoreBuilder.java is removed.

17 files changed, 357 insertions, 242 deletions

diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
index a8d7fb1a..7768287a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
@@ -1,14 +1,20 @@
 package tools.refinery.store.map;
 
+import tools.refinery.store.map.internal.VersionedMapStoreFactoryBuilderImpl;
+
 import java.util.Set;
 
 public interface VersionedMapStore<K, V> {
-        
-        public VersionedMap<K, V> createMap();
 
-        public VersionedMap<K, V> createMap(long state);
-        
-        public Set<Long> getStates();
+        VersionedMap<K, V> createMap();
+
+        VersionedMap<K, V> createMap(long state);
+
+        Set<Long> getStates();
+
+        DiffCursor<K,V> getDiffCursor(long fromState, long toState);
 
-        public DiffCursor<K,V> getDiffCursor(long fromState, long toState);
-}
\ No newline at end of file
+        static <K,V> VersionedMapStoreFactoryBuilder<K,V> builder() {
+                return new VersionedMapStoreFactoryBuilderImpl<>();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java
deleted file mode 100644
index 1a9aa0b3..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package tools.refinery.store.map;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class VersionedMapStoreBuilder<K, V> {
-        public enum StoreStrategy {
-                STATE, DELTA
-        }
-
-        public enum DeltaStorageStrategy {
-                LIST, SET
-        }
-
-        public enum StateStorageStrategy {
-                NO_NODE_CACHE, SHARED_NODE_CACHE, SHARED_NODE_CACHE_IN_GROUP
-        }
-
-        public static <K, V> VersionedMapStoreBuilder<K, V> builder() {
-                return new VersionedMapStoreBuilder<>();
-        }
-        protected VersionedMapStoreBuilder() {
-        }
-        protected VersionedMapStoreBuilder(VersionedMapStoreBuilder<K, V> other) {
-                this.defaultValue = other.defaultValue;
-                this.defaultSet = other.defaultSet;
-                this.strategy = other.strategy;
-                this.stateBasedImmutableWhenCommitting = other.stateBasedImmutableWhenCommitting;
-                this.stateBasedNodeSharingStrategy = other.stateBasedNodeSharingStrategy;
-                this.hashProvider = other.hashProvider;
-                this.deltaStorageStrategy = other.deltaStorageStrategy;
-        }
-        protected boolean defaultSet = false;
-        protected V defaultValue = null;
-        protected StoreStrategy strategy = StoreStrategy.DELTA;
-        protected Boolean stateBasedImmutableWhenCommitting = false;
-        protected StateStorageStrategy stateBasedNodeSharingStrategy = StateStorageStrategy.SHARED_NODE_CACHE_IN_GROUP;
-        protected ContinousHashProvider<K> hashProvider = null;
-        protected DeltaStorageStrategy deltaStorageStrategy = DeltaStorageStrategy.LIST;
-
-        public VersionedMapStoreBuilder<K, V> setDefaultValue(V defaultValue) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.defaultValue = defaultValue;
-                result.defaultSet = true;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setStrategy(StoreStrategy strategy) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.strategy = strategy;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setHashProvider(ContinousHashProvider<K> hashProvider) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.hashProvider = hashProvider;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setStateBasedImmutableWhenCommitting(boolean toImmutableWhenCommitting) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.stateBasedImmutableWhenCommitting = toImmutableWhenCommitting;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setStateBasedNodeSharingStrategy(StateStorageStrategy strategy) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.stateBasedNodeSharingStrategy = strategy;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setDeltaStorageStrategy(DeltaStorageStrategy deltaStorageStrategy) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.deltaStorageStrategy = deltaStorageStrategy;
-                return result;
-        }
-
-        public VersionedMapStore<K, V> buildOne() {
-                if(!defaultSet) {
-                        throw new IllegalStateException("Default value is missing!");
-                }
-                return switch (strategy) {
-                        case DELTA -> new VersionedMapStoreDeltaImpl<>(
-                                        this.deltaStorageStrategy == DeltaStorageStrategy.SET,
-                                        this.defaultValue);
-                        case STATE -> new VersionedMapStoreImpl<>(
-                                        this.hashProvider,
-                                        this.defaultValue,
-                                        new VersionedMapStoreConfiguration(
-                                                        this.stateBasedImmutableWhenCommitting,
-                                                        this.stateBasedNodeSharingStrategy != StateStorageStrategy.NO_NODE_CACHE,
-                                                        this.stateBasedNodeSharingStrategy == StateStorageStrategy.SHARED_NODE_CACHE_IN_GROUP));
-                };
-        }
-
-        public List<VersionedMapStore<K, V>> buildGroup(int amount) {
-                if(!defaultSet) {
-                        throw new IllegalStateException("Default value is missing!");
-                }
-                if (this.strategy == StoreStrategy.STATE &&
-                                this.stateBasedNodeSharingStrategy == StateStorageStrategy.SHARED_NODE_CACHE_IN_GROUP) {
-                        return VersionedMapStoreImpl.createSharedVersionedMapStores(
-                                        amount,
-                                        this.hashProvider,
-                                        this.defaultValue,
-                                        new VersionedMapStoreConfiguration(
-                                                        this.stateBasedImmutableWhenCommitting,
-                                                        true,
-                                                        true));
-                } else {
-                        List<VersionedMapStore<K, V>> result = new ArrayList<>(amount);
-                        for (int i = 0; i < amount; i++) {
-                                result.add(buildOne());
-                        }
-                        return result;
-                }
-        }
-
-        @Override
-        public String toString() {
-                return "VersionedMapStoreBuilder{" +
-                                "defaultValue=" + defaultValue +
-                                ", strategy=" + strategy +
-                                ", stateBasedImmutableWhenCommitting=" + stateBasedImmutableWhenCommitting +
-                                ", stateBasedNodeSharingStrategy=" + stateBasedNodeSharingStrategy +
-                                ", hashProvider=" + hashProvider +
-                                ", deltaStorageStrategy=" + deltaStorageStrategy +
-                                '}';
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java
new file mode 100644
index 00000000..5f882a3a
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java
@@ -0,0 +1,19 @@
+package tools.refinery.store.map;
+
+import java.util.List;
+
+public interface VersionedMapStoreFactory<K,V> {
+        /**
+         * Constructs a new instance of {@link VersionedMap}.
+         * @return The new instance.
+         */
+        VersionedMapStore<K,V> createOne();
+
+        /**
+         * Constructs a group of {@link VersionedMap}s with the same configuration. If possible, the stores share
+         * resources with each other.
+         * @param amount The amount of new instances to be created.
+         * @return A list of new stores with the given number of elements.
+         */
+        List<VersionedMapStore<K, V>> createGroup(int amount);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java
new file mode 100644
index 00000000..9cf17b49
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java
@@ -0,0 +1,24 @@
+package tools.refinery.store.map;
+
+public interface VersionedMapStoreFactoryBuilder<K,V> {
+        enum StoreStrategy {
+                STATE, DELTA
+        }
+
+        enum DeltaTransactionStrategy {
+                LIST, SET
+        }
+
+        enum SharingStrategy {
+                NO_NODE_CACHE, SHARED_NODE_CACHE, SHARED_NODE_CACHE_IN_GROUP
+        }
+
+        VersionedMapStoreFactoryBuilder<K,V> defaultValue(V defaultValue);
+        VersionedMapStoreFactoryBuilder<K,V> strategy(StoreStrategy strategy);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedImmutableWhenCommitting(boolean transformToImmutable);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedSharingStrategy(SharingStrategy sharingStrategy);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedHashProvider(ContinousHashProvider<K> hashProvider);
+        VersionedMapStoreFactoryBuilder<K,V> deltaTransactionStrategy(DeltaTransactionStrategy deltaStrategy);
+
+        VersionedMapStoreFactory<K,V> build();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/DeltaBasedVersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/DeltaBasedVersionedMapStoreFactory.java
new file mode 100644
index 00000000..29ec0da1
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/DeltaBasedVersionedMapStoreFactory.java
@@ -0,0 +1,34 @@
+package tools.refinery.store.map.internal;
+
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreDeltaImpl;
+import tools.refinery.store.map.VersionedMapStoreFactory;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DeltaBasedVersionedMapStoreFactory<K, V> implements VersionedMapStoreFactory<K, V> {
+        private final V defaultValue;
+        private final boolean summarizeChanges;
+
+        public DeltaBasedVersionedMapStoreFactory(V defaultValue,
+                                                                                          VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy deltaTransactionStrategy) {
+                this.defaultValue = defaultValue;
+                this.summarizeChanges = deltaTransactionStrategy == VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.SET;
+        }
+
+        @Override
+        public VersionedMapStore<K, V> createOne() {
+                return new VersionedMapStoreDeltaImpl<>(summarizeChanges, defaultValue);
+        }
+
+        @Override
+        public List<VersionedMapStore<K, V>> createGroup(int amount) {
+                List<VersionedMapStore<K, V>> result = new ArrayList<>(amount);
+                for(int i=0; i<amount; i++) {
+                        result.add(new VersionedMapStoreDeltaImpl<>(summarizeChanges,defaultValue));
+                }
+                return result;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/StateBasedVersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/StateBasedVersionedMapStoreFactory.java
new file mode 100644
index 00000000..80dc347f
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/StateBasedVersionedMapStoreFactory.java
@@ -0,0 +1,33 @@
+package tools.refinery.store.map.internal;
+
+import tools.refinery.store.map.*;
+
+import java.util.List;
+
+public class StateBasedVersionedMapStoreFactory<K, V> implements VersionedMapStoreFactory<K, V> {
+        private final V defaultValue;
+        private final ContinousHashProvider<K> continousHashProvider;
+        private final VersionedMapStoreConfiguration config;
+
+        public StateBasedVersionedMapStoreFactory(V defaultValue, Boolean transformToImmutable, VersionedMapStoreFactoryBuilder.SharingStrategy sharingStrategy, ContinousHashProvider<K> continousHashProvider) {
+                this.defaultValue = defaultValue;
+                this.continousHashProvider = continousHashProvider;
+
+                this.config = new VersionedMapStoreConfiguration(
+                                transformToImmutable,
+                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE || sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP,
+                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP);
+        }
+
+        @Override
+        public VersionedMapStore<K, V> createOne() {
+                return new VersionedMapStoreImpl<>(continousHashProvider, defaultValue, config);
+
+        }
+
+        @Override
+        public List<VersionedMapStore<K, V>> createGroup(int amount) {
+                return VersionedMapStoreImpl.createSharedVersionedMapStores(amount, continousHashProvider, defaultValue,
+                                config);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java
new file mode 100644
index 00000000..3719eef5
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java
@@ -0,0 +1,132 @@
+package tools.refinery.store.map.internal;
+
+import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.VersionedMapStoreFactory;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+
+public class VersionedMapStoreFactoryBuilderImpl<K, V> implements VersionedMapStoreFactoryBuilder<K, V> {
+
+        private boolean defaultSet = false;
+        private V defaultValue;
+        private StoreStrategy strategy = null;
+        private Boolean transformToImmutable = null;
+        private SharingStrategy sharingStrategy = null;
+        private ContinousHashProvider<K> continousHashProvider = null;
+        private DeltaTransactionStrategy deltaTransactionStrategy = null;
+
+        private StoreStrategy checkStrategy() {
+                StoreStrategy currentStrategy = strategy;
+                currentStrategy = mergeStrategies(currentStrategy, transformToImmutable, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, sharingStrategy, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, continousHashProvider, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, deltaTransactionStrategy, StoreStrategy.DELTA);
+                return currentStrategy;
+        }
+
+        private StoreStrategy mergeStrategies(StoreStrategy old, StoreStrategy newStrategy) {
+                if (old != null && newStrategy != null && old != newStrategy) {
+                        throw new IllegalArgumentException("Mixed strategy parametrization in VersionedMap builder!");
+                }
+
+                if (old != null) {
+                        return old;
+                } else {
+                        return newStrategy;
+                }
+        }
+
+        private StoreStrategy mergeStrategies(StoreStrategy old, Object parameter, StoreStrategy newStrategy) {
+                if (parameter != null) {
+                        return mergeStrategies(old, newStrategy);
+                } else {
+                        return old;
+                }
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> defaultValue(V defaultValue) {
+                this.defaultSet = true;
+                this.defaultValue = defaultValue;
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> strategy(StoreStrategy strategy) {
+                this.strategy = strategy;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedImmutableWhenCommitting(boolean transformToImmutable) {
+                this.transformToImmutable = transformToImmutable;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedSharingStrategy(SharingStrategy sharingStrategy) {
+                this.sharingStrategy = sharingStrategy;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedHashProvider(ContinousHashProvider<K> hashProvider) {
+                this.continousHashProvider = hashProvider;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> deltaTransactionStrategy(DeltaTransactionStrategy deltaTransactionStrategy) {
+                this.deltaTransactionStrategy = deltaTransactionStrategy;
+                checkStrategy();
+                return this;
+        }
+
+        private <T> T getOrDefault(T value, T defaultValue) {
+                if(value != null) {
+                        return value;
+                } else {
+                        return defaultValue;
+                }
+        }
+
+        @Override
+        public VersionedMapStoreFactory<K, V> build() {
+                if (!defaultSet) {
+                        throw new IllegalArgumentException("Default value is missing!");
+                }
+                var strategyToUse = checkStrategy();
+                if (strategyToUse == null) {
+                        return new DeltaBasedVersionedMapStoreFactory<>(defaultValue,
+                                        getOrDefault(deltaTransactionStrategy, DeltaTransactionStrategy.LIST));
+                }
+                return switch (strategyToUse) {
+                        case STATE -> {
+                                if(continousHashProvider == null) {
+                                        throw new IllegalArgumentException("Continuous hash provider is missing!");
+                                }
+                                yield new StateBasedVersionedMapStoreFactory<>(defaultValue,
+                                                getOrDefault(transformToImmutable,true),
+                                                getOrDefault(sharingStrategy, SharingStrategy.SHARED_NODE_CACHE_IN_GROUP),
+                                                continousHashProvider);
+                        }
+                        case DELTA -> new DeltaBasedVersionedMapStoreFactory<>(defaultValue,
+                                        getOrDefault(deltaTransactionStrategy, DeltaTransactionStrategy.LIST));
+                };
+        }
+
+        @Override
+        public String toString() {
+                return "VersionedMapStoreBuilder{" +
+                                "defaultValue=" + defaultValue +
+                                ", strategy=" + strategy +
+                                ", stateBasedImmutableWhenCommitting=" + transformToImmutable +
+                                ", stateBasedNodeSharingStrategy=" + sharingStrategy +
+                                ", hashProvider=" + continousHashProvider +
+                                ", deltaStorageStrategy=" + deltaTransactionStrategy +
+                                '}';
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java
index 05cf5a74..993e5531 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java
@@ -1,7 +1,8 @@
 package tools.refinery.store.map.tests;
 
 import org.junit.jupiter.api.Test;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.internal.InOrderMapCursor;
 import tools.refinery.store.map.internal.VersionedMapImpl;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
@@ -11,13 +12,14 @@ import static org.junit.jupiter.api.Assertions.*;
 class InOrderCursorTest {
         @Test
         void testCursor() {
-                var store = VersionedMapStoreBuilder.<Integer,String>builder()
-                                .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
-                                .setStateBasedImmutableWhenCommitting(true)
-                                .setHashProvider(MapTestEnvironment.prepareHashProvider(false))
-                                .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE)
-                                .setDefaultValue("x")
-                                .buildOne();
+                var store = VersionedMapStore.<Integer,String>builder()
+                                .strategy(VersionedMapStoreFactoryBuilder.StoreStrategy.STATE)
+                                .stateBasedImmutableWhenCommitting(true)
+                                .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE)
+                                .defaultValue("x")
+                                .build()
+                                .createOne();
 
                 VersionedMapImpl<Integer,String> map = (VersionedMapImpl<Integer,String>) store.createMap();
                 checkMove(map,0);
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
index 2216db76..6889fd07 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
@@ -2,7 +2,6 @@ package tools.refinery.store.map.tests;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
 import tools.refinery.store.map.VersionedMapStoreImpl;
 import tools.refinery.store.model.TupleHashProvider;
 import tools.refinery.store.tuple.Tuple;
@@ -23,7 +22,7 @@ class MapUnitTests {
         @Test
         void deltaRestoreTest() {
                 VersionedMapStore<Integer,String> store =
-                                VersionedMapStoreBuilder.<Integer,String>builder().setDefaultValue("x").buildOne();
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
                 var map = store.createMap();
                 map.put(1,"val");
                 var version1 = map.commit();
@@ -36,7 +35,7 @@ class MapUnitTests {
         @Test
         void deltaRestoreTest2() {
                 VersionedMapStore<Integer,String> store =
-                                VersionedMapStoreBuilder.<Integer,String>builder().setDefaultValue("x").buildOne();
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
                 var map = store.createMap();
                 map.put(1,"x");
                 var version1 = map.commit();
@@ -48,7 +47,7 @@ class MapUnitTests {
         @Test
         void deltaRestoreTest3() {
                 VersionedMapStore<Integer,String> store =
-                                VersionedMapStoreBuilder.<Integer,String>builder().setDefaultValue("x").buildOne();
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
                 var map = store.createMap();
                 map.commit();
                 map.put(1,"1");
@@ -71,7 +70,7 @@ class MapUnitTests {
         @Test
         void deltaRestoreTest4() {
                 VersionedMapStore<Integer,String> store =
-                                VersionedMapStoreBuilder.<Integer,String>builder().setDefaultValue("x").buildOne();
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
                 var map = store.createMap();
                 map.commit();
                 map.put(1,"1");
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
index 14a9e2e0..7977f772 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
@@ -1,30 +1,29 @@
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.fail;
-
-import java.util.Random;
-import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.Random;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.fail;
 import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 
 class CommitFuzzTest {
 
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         boolean nullDefault, int commitFrequency,
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
                 var sut = store.createMap();
                 MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
@@ -61,7 +60,7 @@ class CommitFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
@@ -76,7 +75,7 @@ class CommitFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
index b462ed40..99e76649 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
@@ -5,7 +5,10 @@ import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import tools.refinery.store.map.*;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -16,12 +19,13 @@ import java.util.List;
 import java.util.Random;
 import java.util.stream.Stream;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.fail;
 import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 
 class ContentEqualsFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         boolean nullDefault, int commitFrequency,
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
 
@@ -30,10 +34,10 @@ class ContentEqualsFuzzTest {
                 iterativeRandomPutsAndCommitsThenCompare(scenario, builder, steps, maxKey, values, r, commitFrequency);
         }
 
-        private void iterativeRandomPutsAndCommitsThenCompare(String scenario, VersionedMapStoreBuilder<Integer, String> builder,
+        private void iterativeRandomPutsAndCommitsThenCompare(String scenario, VersionedMapStoreFactoryBuilder<Integer, String> builder,
                                                                                                                   int steps, int maxKey, String[] values, Random r,
                                                                                                                   int commitFrequency) {
-                VersionedMapStore<Integer, String> store1 = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store1 = builder.defaultValue(values[0]).build().createOne();
                 VersionedMap<Integer, String> sut1 = store1.createMap();
 
                 // Fill one map
@@ -63,7 +67,7 @@ class ContentEqualsFuzzTest {
                 // Randomize the order of the content
                 Collections.shuffle(content, r);
 
-                VersionedMapStore<Integer, String> store2 = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store2 = builder.defaultValue(values[0]).build().createOne();
                 VersionedMap<Integer, String> sut2 = store2.createMap();
                 int index2 = 1;
                 for (SimpleEntry<Integer, String> entry : content) {
@@ -88,7 +92,7 @@ class ContentEqualsFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
@@ -103,7 +107,7 @@ class ContentEqualsFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 defaultNull, commitFrequency, builder);
         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
index b087906d..3a8852a9 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
@@ -8,7 +8,7 @@ import org.junit.jupiter.params.provider.MethodSource;
 import tools.refinery.store.map.DiffCursor;
 import tools.refinery.store.map.VersionedMap;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -21,10 +21,10 @@ import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 class DiffCursorFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault,
                                                          int commitFrequency, boolean commitBeforeDiffCursor,
-                                                         VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
                 iterativeRandomPutsAndCommitsThenDiffCursor(scenario, store, steps, maxKey, values, seed, commitFrequency,
                                 commitBeforeDiffCursor);
         }
@@ -109,7 +109,7 @@ class DiffCursorFuzzTest {
         @Tag("fuzz")
         void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
                                                   int commitFrequency, int seed, boolean commitBeforeDiffCursor,
-                                                  VersionedMapStoreBuilder<Integer, String> builder) {
+                                                  VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("DiffCursorS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
                                 noKeys, noValues, nullDefault, commitFrequency, commitBeforeDiffCursor, builder);
         }
@@ -124,7 +124,7 @@ class DiffCursorFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                        int seed, boolean commitBeforeDiffCursor, VersionedMapStoreBuilder<Integer, String> builder) {
+                        int seed, boolean commitBeforeDiffCursor, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("DiffCursorS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, commitBeforeDiffCursor, builder);
         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
index ec2224b4..ea58e1b7 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
@@ -1,32 +1,31 @@
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
-import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
-
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class MultiThreadFuzzTest {
         public static final int noThreads = 10;
 
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
 
                 // initialize runnables
                 MultiThreadTestRunnable[] runnables = new MultiThreadTestRunnable[noThreads];
@@ -73,7 +72,7 @@ class MultiThreadFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull,
-                                                           int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                           int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("MultiThreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency +
                                  "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, builder);
         }
@@ -88,7 +87,7 @@ class MultiThreadFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
-                                                          int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
index bdf72ce4..61b17362 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
@@ -18,10 +18,10 @@ import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class MutableFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         boolean nullDefault, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
                 VersionedMap<Integer, String> sut = store.createMap();
                 MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
@@ -56,7 +56,7 @@ class MutableFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int seed,
-                                                  VersionedMapStoreBuilder<Integer, String> builder) {
+                                                  VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest(
                                 "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed,
                                 seed, steps, noKeys, noValues, defaultNull, builder);
@@ -72,7 +72,7 @@ class MutableFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int seed,
-                                                         VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest(
                                 "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed,
                                 seed, steps, noKeys, noValues, nullDefault, builder);
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
index 568aaac9..1661cccb 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
@@ -1,31 +1,31 @@
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.fail;
-import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Random;
-import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
-import tools.refinery.store.map.*;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class RestoreFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
                                                          boolean nullDefault, int commitFrequency,
-                                                         VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
 
                 iterativeRandomPutsAndCommitsThenRestore(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
@@ -84,7 +84,7 @@ class RestoreFuzzTest {
         @Timeout(value = 10)
         @Tag("smoke")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
@@ -99,7 +99,7 @@ class RestoreFuzzTest {
         @Tag("smoke")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java
index e7d49227..0e1f9f9f 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java
@@ -6,7 +6,7 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -15,10 +15,10 @@ import java.util.stream.Stream;
 import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 
 class SingleThreadFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
 
                 // initialize runnables
                 MultiThreadTestRunnable runnable = new MultiThreadTestRunnable(scenario, store, steps, maxKey, values, seed, commitFrequency);
@@ -35,7 +35,7 @@ class SingleThreadFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull,
-                                                          int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("SingleThreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency +
                                 "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, builder);
         }
@@ -50,7 +50,7 @@ class SingleThreadFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
-                                                          int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("SingleThreadS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java
index b344d9b9..94c9cba7 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java
@@ -1,6 +1,7 @@
 package tools.refinery.store.map.tests.fuzz.utils;
 
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 public final class FuzzTestCollections {
@@ -12,34 +13,27 @@ public final class FuzzTestCollections {
         public static final Object[] randomSeedOptions = {1};
         public static final Object[] storeConfigs = {
                         // State based
-                        VersionedMapStoreBuilder.<Integer,String>builder()
-                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
-                                        .setStateBasedImmutableWhenCommitting(true)
-                                        .setHashProvider(MapTestEnvironment.prepareHashProvider(false))
-                                        .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy
-                                        .SHARED_NODE_CACHE),
-                        VersionedMapStoreBuilder.<Integer,String>builder()
-                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
-                                        .setStateBasedImmutableWhenCommitting(true)
-                                        .setHashProvider(MapTestEnvironment.prepareHashProvider(true))
-                                        .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy
-                                        .SHARED_NODE_CACHE),
-                        VersionedMapStoreBuilder.<Integer,String>builder()
-                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
-                                        .setStateBasedImmutableWhenCommitting(false)
-                                        .setHashProvider(MapTestEnvironment.prepareHashProvider(false))
-                                        .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE),
-                        VersionedMapStoreBuilder.<Integer,String>builder()
-                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
-                                        .setStateBasedImmutableWhenCommitting(false)
-                                        .setHashProvider(MapTestEnvironment.prepareHashProvider(false))
-                                        .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.NO_NODE_CACHE),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(true)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(true)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(true))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(false)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(false)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.NO_NODE_CACHE),
+
                         // Delta based
-                        VersionedMapStoreBuilder.<Integer,String>builder()
-                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.DELTA)
-                                        .setDeltaStorageStrategy(VersionedMapStoreBuilder.DeltaStorageStrategy.SET),
-                        VersionedMapStoreBuilder.<Integer,String>builder()
-                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.DELTA)
-                                        .setDeltaStorageStrategy(VersionedMapStoreBuilder.DeltaStorageStrategy.LIST)
+                        VersionedMapStore.<Integer,String>builder()
+                                        .deltaTransactionStrategy(VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.SET),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .deltaTransactionStrategy(VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.LIST)
         };
 }