Versioned.commit + Versioned.restore uses Version instead of long.

When a Version is collected by gc, the store lets the state get collected by gc as well.

23 files changed, 258 insertions, 162 deletions

diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/Version.java b/subprojects/store/src/main/java/tools/refinery/store/map/Version.java
new file mode 100644
index 00000000..fa2734e4
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/Version.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map;
+
+/**
+ * Interface denoting versions of {@link Versioned}.
+ */
+public interface Version {
+        /**
+         * Hashcode should be updated in accordance with equals.
+         * @return a hashcode of the object.
+         */
+        int hashCode();
+
+        /**
+         * Equivalence of two {@link Version}. This equivalence must satisfy the following constraint (in addition to the
+         * constraints of {@link Object#equals(Object)}: if {@code v1} and {@code v2} are {@link Version}s, and {@code v1
+         * .equals(v2)}, then {@code versioned.restore(v1)} must be {@code equals} to {@code versioned.restore(v2)}.
+         * @param o the other object.
+         * @return weather the two versions are equals.
+         */
+        boolean equals(Object o);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/Versioned.java b/subprojects/store/src/main/java/tools/refinery/store/map/Versioned.java
index 55720db3..da12b0a9 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/Versioned.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/Versioned.java
@@ -5,8 +5,20 @@
  */
 package tools.refinery.store.map;
 
+/**
+ * Object that can save and restore its state.
+ */
 public interface Versioned {
-        public long commit();
-        //maybe revert()?
-        public void restore(long state);
+        /**
+         * Saves the state of the object.
+         * @return an object that marks the version of the object at the time the function was called.
+         */
+        Version commit();
+
+        /**
+         * Restores the state of the object.
+         * @param state a {@link Version} object that marks the version. The state must be a {@link Version} object
+         *                 returned by a previous {@link #commit()}!
+         */
+        void restore(Version state);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
index c8226c3e..28194b58 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMap.java
@@ -16,5 +16,5 @@ public non-sealed interface VersionedMap<K, V> extends AnyVersionedMap {
 
         void putAll(Cursor<K, V> cursor);
 
-        DiffCursor<K, V> getDiffCursor(long state);
+        DiffCursor<K, V> getDiffCursor(Version state);
 }
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 b24c404c..55cf08a5 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
@@ -7,17 +7,13 @@ package tools.refinery.store.map;
 
 import tools.refinery.store.map.internal.VersionedMapStoreFactoryBuilderImpl;
 
-import java.util.Set;
-
 public interface VersionedMapStore<K, V> {
 
         VersionedMap<K, V> createMap();
 
-        VersionedMap<K, V> createMap(long state);
-
-        Set<Long> getStates();
+        VersionedMap<K, V> createMap(Version state);
 
-        DiffCursor<K,V> getDiffCursor(long fromState, long toState);
+        DiffCursor<K,V> getDiffCursor(Version fromState, Version toState);
 
         static <K,V> VersionedMapStoreFactoryBuilder<K,V> builder() {
                 return new VersionedMapStoreFactoryBuilderImpl<>();
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
index 6b4fc2a0..0ac196f2 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java
@@ -20,6 +20,7 @@ public interface VersionedMapStoreFactoryBuilder<K,V> {
 
         VersionedMapStoreFactoryBuilder<K,V> defaultValue(V defaultValue);
         VersionedMapStoreFactoryBuilder<K,V> strategy(StoreStrategy strategy);
+        VersionedMapStoreFactoryBuilder<K,V> versionFreeing(boolean enabled);
         VersionedMapStoreFactoryBuilder<K,V> stateBasedImmutableWhenCommitting(boolean transformToImmutable);
         VersionedMapStoreFactoryBuilder<K,V> stateBasedSharingStrategy(SharingStrategy sharingStrategy);
         VersionedMapStoreFactoryBuilder<K,V> stateBasedHashProvider(ContinuousHashProvider<K> hashProvider);
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
index 47470236..9f419ce1 100644
--- 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
@@ -18,6 +18,7 @@ public class VersionedMapStoreFactoryBuilderImpl<K, V> implements VersionedMapSt
         private StoreStrategy strategy = null;
         private Boolean transformToImmutable = null;
         private SharingStrategy sharingStrategy = null;
+        private Boolean enableVersionFreeing = null;
         private ContinuousHashProvider<K> continuousHashProvider = null;
         private DeltaTransactionStrategy deltaTransactionStrategy = null;
 
@@ -65,6 +66,13 @@ public class VersionedMapStoreFactoryBuilderImpl<K, V> implements VersionedMapSt
         }
 
         @Override
+        public VersionedMapStoreFactoryBuilder<K, V> versionFreeing(boolean enabled) {
+                this.enableVersionFreeing = enabled;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
         public VersionedMapStoreFactoryBuilder<K, V> stateBasedImmutableWhenCommitting(boolean transformToImmutable) {
                 this.transformToImmutable = transformToImmutable;
                 checkStrategy();
@@ -118,6 +126,7 @@ public class VersionedMapStoreFactoryBuilderImpl<K, V> implements VersionedMapSt
                                 yield new StateBasedVersionedMapStoreFactory<>(defaultValue,
                                                 getOrDefault(transformToImmutable,true),
                                                 getOrDefault(sharingStrategy, SharingStrategy.SHARED_NODE_CACHE_IN_GROUP),
+                                                getOrDefault(enableVersionFreeing, true),
                                                 continuousHashProvider);
                         }
                         case DELTA -> new DeltaBasedVersionedMapStoreFactory<>(defaultValue,
@@ -127,13 +136,15 @@ public class VersionedMapStoreFactoryBuilderImpl<K, V> implements VersionedMapSt
 
         @Override
         public String toString() {
-                return "VersionedMapStoreBuilder{" +
-                                "defaultValue=" + defaultValue +
+                return "VersionedMapStoreFactoryBuilderImpl{" +
+                                "defaultSet=" + defaultSet +
+                                ", defaultValue=" + defaultValue +
                                 ", strategy=" + strategy +
-                                ", stateBasedImmutableWhenCommitting=" + transformToImmutable +
-                                ", stateBasedNodeSharingStrategy=" + sharingStrategy +
-                                ", hashProvider=" + continuousHashProvider +
-                                ", deltaStorageStrategy=" + deltaTransactionStrategy +
+                                ", transformToImmutable=" + transformToImmutable +
+                                ", sharingStrategy=" + sharingStrategy +
+                                ", enableVersionFreeing=" + enableVersionFreeing +
+                                ", continuousHashProvider=" + continuousHashProvider +
+                                ", deltaTransactionStrategy=" + deltaTransactionStrategy +
                                 '}';
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapTransaction.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapTransaction.java
index 7f9ccd7f..6f3fa6d7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapTransaction.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/MapTransaction.java
@@ -5,17 +5,19 @@
  */
 package tools.refinery.store.map.internal.delta;
 
+import tools.refinery.store.map.Version;
+
 import java.util.Arrays;
 import java.util.Objects;
 
-public record MapTransaction<K, V>(MapDelta<K, V>[] deltas, long version, MapTransaction<K, V> parent) {
+public record MapTransaction<K, V>(MapDelta<K, V>[] deltas, MapTransaction<K, V> parent, int depth) implements Version {
 
         @Override
         public int hashCode() {
                 final int prime = 31;
                 int result = 1;
                 result = prime * result + Arrays.hashCode(deltas);
-                result = prime * result + Objects.hash(parent, version);
+                result = prime * result + Objects.hash(parent, depth);
                 return result;
         }
 
@@ -29,11 +31,11 @@ public record MapTransaction<K, V>(MapDelta<K, V>[] deltas, long version, MapTra
                         return false;
                 @SuppressWarnings("unchecked")
                 MapTransaction<K, V> other = (MapTransaction<K, V>) obj;
-                return Arrays.equals(deltas, other.deltas) && Objects.equals(parent, other.parent) && version == other.version;
+                return depth == other.depth && Objects.equals(parent, other.parent) && Arrays.equals(deltas, other.deltas);
         }
 
         @Override
         public String toString() {
-                return "MapTransaction " + version + " " + Arrays.toString(deltas);
+                return "MapTransaction " + depth + " " + Arrays.toString(deltas);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java
index 5bb864ac..c19cc817 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java
@@ -38,15 +38,15 @@ public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
         }
 
         @Override
-        public long commit() {
+        public Version commit() {
                 MapDelta<K, V>[] deltas = uncommittedStore.extractAndDeleteDeltas();
-                long[] versionContainer = new long[1];
-                this.previous = this.store.appendTransaction(deltas, previous, versionContainer);
-                return versionContainer[0];
+                final MapTransaction<K,V> committedTransaction = this.store.appendTransaction(deltas, previous);
+                this.previous = committedTransaction;
+                return committedTransaction;
         }
 
         @Override
-        public void restore(long state) {
+        public void restore(Version state) {
                 // 1. restore uncommitted states
                 MapDelta<K, V>[] uncommitted = this.uncommittedStore.extractAndDeleteDeltas();
                 if (uncommitted != null) {
@@ -61,7 +61,7 @@ public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
                         this.forward(forward);
                 } else {
                         List<MapDelta<K, V>[]> backward = new ArrayList<>();
-                        parent = this.store.getPath(this.previous.version(), state, backward, forward);
+                        parent = this.store.getPath(this.previous, state, backward, forward);
                         this.backward(backward);
                         this.forward(forward);
                 }
@@ -75,12 +75,16 @@ public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
         }
 
         protected void backward(List<MapDelta<K, V>[]> changes) {
+                //Currently, this loop statement is faster.
+                //noinspection ForLoopReplaceableByForEach
                 for (int i = 0; i < changes.size(); i++) {
                         backward(changes.get(i));
                 }
         }
 
         protected void forward(MapDelta<K, V>[] changes) {
+                //Currently, this loop statement is faster.
+                //noinspection ForLoopReplaceableByForEach
                 for (int i = 0; i < changes.length; i++) {
                         final MapDelta<K, V> change = changes[i];
                         K key = change.getKey();
@@ -168,7 +172,7 @@ public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
         }
 
         @Override
-        public DiffCursor<K, V> getDiffCursor(long state) {
+        public DiffCursor<K, V> getDiffCursor(Version state) {
                 MapDelta<K, V>[] backward = this.uncommittedStore.extractDeltas();
                 List<MapDelta<K, V>[]> backwardTransactions = new ArrayList<>();
                 List<MapDelta<K, V>[]> forwardTransactions = new ArrayList<>();
@@ -178,7 +182,7 @@ public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
                 }
 
                 if (this.previous != null) {
-                        store.getPath(this.previous.version(), state, backwardTransactions, forwardTransactions);
+                        store.getPath(this.previous, state, backwardTransactions, forwardTransactions);
                 } else {
                         store.getPath(state, forwardTransactions);
                 }
@@ -216,5 +220,19 @@ public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
                                 throw new IllegalStateException("null value stored in map!");
                         }
                 }
+                MapTransaction<K,V> transaction = this.previous;
+                while(transaction != null) {
+                        MapTransaction<K,V> parent = transaction.parent();
+                        if(parent != null) {
+                                if(parent.depth() != transaction.depth()-1) {
+                                        throw new IllegalStateException("Parent depths are inconsistent!");
+                                }
+                        } else {
+                                if(transaction.depth() != 0) {
+                                        throw new IllegalArgumentException("Root depth is not 0!");
+                                }
+                        }
+                        transaction = transaction.parent();
+                }
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapStoreDeltaImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapStoreDeltaImpl.java
index 7f56ea77..ed169409 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapStoreDeltaImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapStoreDeltaImpl.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.map.internal.delta;
 
 import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.map.VersionedMap;
 import tools.refinery.store.map.VersionedMapStore;
 
@@ -18,10 +19,6 @@ public class VersionedMapStoreDeltaImpl<K, V> implements VersionedMapStore<K, V>
         // Static data
         protected final V defaultValue;
 
-        // Dynamic data
-        protected final Map<Long, MapTransaction<K, V>> states = new HashMap<>();
-        protected long nextID = 0;
-
         public VersionedMapStoreDeltaImpl(boolean summarizeChanges, V defaultValue) {
                 this.summarizeChanges = summarizeChanges;
                 this.defaultValue = defaultValue;
@@ -33,30 +30,32 @@ public class VersionedMapStoreDeltaImpl<K, V> implements VersionedMapStore<K, V>
         }
 
         @Override
-        public VersionedMap<K, V> createMap(long state) {
+        public VersionedMap<K, V> createMap(Version state) {
                 VersionedMapDeltaImpl<K, V> result = new VersionedMapDeltaImpl<>(this, this.summarizeChanges, this.defaultValue);
                 result.restore(state);
                 return result;
         }
 
-        public synchronized MapTransaction<K, V> appendTransaction(MapDelta<K, V>[] deltas, MapTransaction<K, V> previous, long[] versionContainer) {
-                long version = nextID++;
-                versionContainer[0] = version;
+        public MapTransaction<K, V> appendTransaction(MapDelta<K, V>[] deltas, MapTransaction<K, V> previous) {
                 if (deltas == null) {
-                        states.put(version, previous);
                         return previous;
                 } else {
-                        MapTransaction<K, V> transaction = new MapTransaction<>(deltas, version, previous);
-                        states.put(version, transaction);
-                        return transaction;
+                        final int depth;
+                        if(previous != null) {
+                                depth = previous.depth()+1;
+                        } else {
+                                depth = 0;
+                        }
+                        return new MapTransaction<>(deltas, previous, depth);
                 }
         }
 
-        private synchronized MapTransaction<K, V> getState(long state) {
-                return states.get(state);
+        @SuppressWarnings("unchecked")
+        private MapTransaction<K, V> getState(Version state) {
+                return (MapTransaction<K, V>) state;
         }
 
-        public MapTransaction<K, V> getPath(long to, List<MapDelta<K, V>[]> forwardTransactions) {
+        public MapTransaction<K, V> getPath(Version to, List<MapDelta<K, V>[]> forwardTransactions) {
                 final MapTransaction<K, V> target = getState(to);
                 MapTransaction<K, V> toTransaction = target;
                 while (toTransaction != null) {
@@ -66,7 +65,7 @@ public class VersionedMapStoreDeltaImpl<K, V> implements VersionedMapStore<K, V>
                 return target;
         }
 
-        public MapTransaction<K, V> getPath(long from, long to,
+        public MapTransaction<K, V> getPath(Version from, Version to,
                                                 List<MapDelta<K, V>[]> backwardTransactions,
                                                 List<MapDelta<K, V>[]> forwardTransactions) {
                 MapTransaction<K, V> fromTransaction = getState(from);
@@ -74,7 +73,7 @@ public class VersionedMapStoreDeltaImpl<K, V> implements VersionedMapStore<K, V>
                 MapTransaction<K, V> toTransaction = target;
 
                 while (fromTransaction != toTransaction) {
-                        if (fromTransaction == null || (toTransaction != null && fromTransaction.version() < toTransaction.version())) {
+                        if (fromTransaction == null || (toTransaction != null && fromTransaction.depth() < toTransaction.depth())) {
                                 forwardTransactions.add(toTransaction.deltas());
                                 toTransaction = toTransaction.parent();
                         } else {
@@ -85,14 +84,8 @@ public class VersionedMapStoreDeltaImpl<K, V> implements VersionedMapStore<K, V>
                 return target;
         }
 
-
-        @Override
-        public synchronized Set<Long> getStates() {
-                return new HashSet<>(states.keySet());
-        }
-
         @Override
-        public DiffCursor<K, V> getDiffCursor(long fromState, long toState) {
+        public DiffCursor<K, V> getDiffCursor(Version fromState, Version toState) {
                 List<MapDelta<K, V>[]> backwardTransactions = new ArrayList<>();
                 List<MapDelta<K, V>[]> forwardTransactions = new ArrayList<>();
                 getPath(fromState, toState, backwardTransactions, forwardTransactions);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/ImmutableNode.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/ImmutableNode.java
index 722f9ed7..5b1d8b77 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/ImmutableNode.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/ImmutableNode.java
@@ -9,8 +9,9 @@ import java.util.Arrays;
 import java.util.Map;
 
 import tools.refinery.store.map.ContinuousHashProvider;
+import tools.refinery.store.map.Version;
 
-public class ImmutableNode<K, V> extends Node<K, V> {
+public class ImmutableNode<K, V> extends Node<K, V> implements Version {
         /**
          * Bitmap defining the stored key and values.
          */
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/StateBasedVersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/StateBasedVersionedMapStoreFactory.java
index 9409ace0..ccc791a8 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/StateBasedVersionedMapStoreFactory.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/StateBasedVersionedMapStoreFactory.java
@@ -14,14 +14,19 @@ public class StateBasedVersionedMapStoreFactory<K, V> implements VersionedMapSto
         private final ContinuousHashProvider<K> continuousHashProvider;
         private final VersionedMapStoreStateConfiguration config;
 
-        public StateBasedVersionedMapStoreFactory(V defaultValue, Boolean transformToImmutable, VersionedMapStoreFactoryBuilder.SharingStrategy sharingStrategy, ContinuousHashProvider<K> continuousHashProvider) {
+        public StateBasedVersionedMapStoreFactory(V defaultValue, Boolean transformToImmutable,
+                                                                                          VersionedMapStoreFactoryBuilder.SharingStrategy sharingStrategy,
+                                                                                          boolean versionFreeingEnabled,
+                                                                                          ContinuousHashProvider<K> continuousHashProvider) {
                 this.defaultValue = defaultValue;
                 this.continuousHashProvider = continuousHashProvider;
 
                 this.config = new VersionedMapStoreStateConfiguration(
                                 transformToImmutable,
-                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE || sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP,
-                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP);
+                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE
+                                                || sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP,
+                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP,
+                                versionFreeingEnabled);
         }
 
         @Override
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStateImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStateImpl.java
index 817fc70b..57eeccf6 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStateImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStateImpl.java
@@ -115,7 +115,7 @@ public class VersionedMapStateImpl<K, V> implements VersionedMap<K, V> {
         }
 
         @Override
-        public DiffCursor<K, V> getDiffCursor(long toVersion) {
+        public DiffCursor<K, V> getDiffCursor(Version toVersion) {
                 InOrderMapCursor<K, V> fromCursor = new InOrderMapCursor<>(this);
                 VersionedMapStateImpl<K, V> toMap = (VersionedMapStateImpl<K, V>) this.store.createMap(toVersion);
                 InOrderMapCursor<K, V> toCursor = new InOrderMapCursor<>(toMap);
@@ -124,7 +124,7 @@ public class VersionedMapStateImpl<K, V> implements VersionedMap<K, V> {
 
 
         @Override
-        public long commit() {
+        public Version commit() {
                 return this.store.commit(root, this);
         }
 
@@ -133,7 +133,7 @@ public class VersionedMapStateImpl<K, V> implements VersionedMap<K, V> {
         }
 
         @Override
-        public void restore(long state) {
+        public void restore(Version state) {
                 root = this.store.revert(state);
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateConfiguration.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateConfiguration.java
index 45f30cc7..6650f565 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateConfiguration.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateConfiguration.java
@@ -14,11 +14,12 @@ public class VersionedMapStoreStateConfiguration {
 
         }
         public VersionedMapStoreStateConfiguration(boolean immutableWhenCommitting, boolean sharedNodeCacheInStore,
-                                                                                           boolean sharedNodeCacheInStoreGroups) {
+                                                                                           boolean sharedNodeCacheInStoreGroups, boolean versionFreeingEnabled) {
                 super();
                 this.immutableWhenCommitting = immutableWhenCommitting;
                 this.sharedNodeCacheInStore = sharedNodeCacheInStore;
                 this.sharedNodeCacheInStoreGroups = sharedNodeCacheInStoreGroups;
+                this.versionFreeingEnabled = versionFreeingEnabled;
         }
 
         /**
@@ -53,4 +54,9 @@ public class VersionedMapStoreStateConfiguration {
         public boolean isSharedNodeCacheInStoreGroups() {
                 return sharedNodeCacheInStoreGroups;
         }
+
+        private boolean versionFreeingEnabled = true;
+        public boolean isVersionFreeingEnabled() {
+                return versionFreeingEnabled;
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateImpl.java
index 0651772a..8ff3f8e7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/state/VersionedMapStoreStateImpl.java
@@ -17,10 +17,7 @@ public class VersionedMapStoreStateImpl<K, V> implements VersionedMapStore<K, V>
         protected final ContinuousHashProvider<K> hashProvider;
         protected final V defaultValue;
 
-        // Dynamic data
-        protected final Map<Long, ImmutableNode<K, V>> states = new HashMap<>();
         protected final Map<Node<K, V>, ImmutableNode<K, V>> nodeCache;
-        protected long nextID = 0;
 
         public VersionedMapStoreStateImpl(ContinuousHashProvider<K> hashProvider, V defaultValue,
                                                                           VersionedMapStoreStateConfiguration config) {
@@ -28,7 +25,7 @@ public class VersionedMapStoreStateImpl<K, V> implements VersionedMapStore<K, V>
                 this.hashProvider = hashProvider;
                 this.defaultValue = defaultValue;
                 if (config.isSharedNodeCacheInStore()) {
-                        nodeCache = new HashMap<>();
+                        nodeCache = createNoteCache(config);
                 } else {
                         nodeCache = null;
                 }
@@ -53,7 +50,7 @@ public class VersionedMapStoreStateImpl<K, V> implements VersionedMapStore<K, V>
                 if (config.isSharedNodeCacheInStoreGroups()) {
                         Map<Node<K, V>, ImmutableNode<K, V>> nodeCache;
                         if (config.isSharedNodeCacheInStore()) {
-                                nodeCache = new HashMap<>();
+                                nodeCache = createNoteCache(config);
                         } else {
                                 nodeCache = null;
                         }
@@ -68,39 +65,36 @@ public class VersionedMapStoreStateImpl<K, V> implements VersionedMapStore<K, V>
                 return result;
         }
 
+        private static <K,V> Map<K,V> createNoteCache(VersionedMapStoreStateConfiguration config) {
+                if(config.isVersionFreeingEnabled()) {
+                        return new WeakHashMap<>();
+                } else {
+                        return new HashMap<>();
+                }
+        }
+
         public static <K, V> List<VersionedMapStore<K, V>> createSharedVersionedMapStores(int amount,
                                                                                                                                                                           ContinuousHashProvider<K> hashProvider, V defaultValue) {
                 return createSharedVersionedMapStores(amount, hashProvider, defaultValue, new VersionedMapStoreStateConfiguration());
         }
 
         @Override
-        public synchronized Set<Long> getStates() {
-                return new HashSet<>(states.keySet());
-        }
-
-        @Override
         public VersionedMap<K, V> createMap() {
                 return new VersionedMapStateImpl<>(this, hashProvider, defaultValue);
         }
 
         @Override
-        public VersionedMap<K, V> createMap(long state) {
+        public VersionedMap<K, V> createMap(Version state) {
                 ImmutableNode<K, V> data = revert(state);
                 return new VersionedMapStateImpl<>(this, hashProvider, defaultValue, data);
         }
 
-        public synchronized ImmutableNode<K, V> revert(long state) {
-                if (states.containsKey(state)) {
-                        return states.get(state);
-                } else {
-                        ArrayList<Long> existingKeys = new ArrayList<>(states.keySet());
-                        Collections.sort(existingKeys);
-                        throw new IllegalArgumentException("Store does not contain state " + state + "! Available states: "
-                                        + Arrays.toString(existingKeys.toArray()));
-                }
+        @SuppressWarnings("unchecked")
+        public synchronized ImmutableNode<K, V> revert(Version state) {
+                return (ImmutableNode<K, V>) state;
         }
 
-        public synchronized long commit(Node<K, V> data, VersionedMapStateImpl<K, V> mapToUpdateRoot) {
+        public synchronized Version commit(Node<K, V> data, VersionedMapStateImpl<K, V> mapToUpdateRoot) {
                 ImmutableNode<K, V> immutable;
                 if (data != null) {
                         immutable = data.toImmutable(this.nodeCache);
@@ -108,18 +102,14 @@ public class VersionedMapStoreStateImpl<K, V> implements VersionedMapStore<K, V>
                         immutable = null;
                 }
 
-                if (nextID == Long.MAX_VALUE)
-                        throw new IllegalStateException("Map store run out of Id-s");
-                long id = nextID++;
-                this.states.put(id, immutable);
                 if (this.immutableWhenCommitting) {
                         mapToUpdateRoot.setRoot(immutable);
                 }
-                return id;
+                return immutable;
         }
 
         @Override
-        public DiffCursor<K, V> getDiffCursor(long fromState, long toState) {
+        public DiffCursor<K, V> getDiffCursor(Version fromState, Version toState) {
                 VersionedMapStateImpl<K, V> map1 = (VersionedMapStateImpl<K, V>) createMap(fromState);
                 VersionedMapStateImpl<K, V> map2 = (VersionedMapStateImpl<K, V>) createMap(toState);
                 InOrderMapCursor<K, V> cursor1 = new InOrderMapCursor<>(map1);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
index 26ad9a69..72f188d3 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
@@ -7,6 +7,7 @@ package tools.refinery.store.model;
 
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
@@ -22,7 +23,7 @@ public non-sealed interface Interpretation<T> extends AnyInterpretation {
 
         void putAll(Cursor<Tuple, T> cursor);
 
-        DiffCursor<Tuple, T> getDiffCursor(long to);
+        DiffCursor<Tuple, T> getDiffCursor(Version to);
 
         void addListener(InterpretationListener<T> listener, boolean alsoWhenRestoring);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
index d58d91c3..a028b81b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.model;
 
 import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.map.Versioned;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
@@ -13,11 +14,10 @@ import tools.refinery.store.representation.Symbol;
 import java.util.Optional;
 
 public interface Model extends Versioned {
-        long NO_STATE_ID = -1;
-
+        Version NO_STATE_ID = null;
         ModelStore getStore();
 
-        long getState();
+        Version getState();
 
         boolean hasUncommittedChanges();
 
@@ -27,7 +27,7 @@ public interface Model extends Versioned {
 
         <T> Interpretation<T> getInterpretation(Symbol<T> symbol);
 
-        ModelDiffCursor getDiffCursor(long to);
+        ModelDiffCursor getDiffCursor(Version to);
 
         <T extends ModelAdapter> Optional<T> tryGetAdapter(Class<? extends T> adapterType);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java
index a9ad8cfd..703ee10a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java
@@ -5,6 +5,8 @@
  */
 package tools.refinery.store.model;
 
+import tools.refinery.store.map.Version;
+
 public interface ModelListener {
         default void beforeCommit() {
         }
@@ -12,7 +14,7 @@ public interface ModelListener {
         default void afterCommit() {
         }
 
-        default void beforeRestore(long state) {
+        default void beforeRestore(Version state) {
         }
 
         default void afterRestore() {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
index b10eb8a4..89382b3a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
@@ -6,23 +6,21 @@
 package tools.refinery.store.model;
 
 import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.model.internal.ModelStoreBuilderImpl;
 import tools.refinery.store.representation.AnySymbol;
 
 import java.util.Collection;
 import java.util.Optional;
-import java.util.Set;
 
 public interface ModelStore {
         Collection<AnySymbol> getSymbols();
 
         Model createEmptyModel();
 
-        Model createModelForState(long state);
+        Model createModelForState(Version state);
 
-        Set<Long> getStates();
-
-        ModelDiffCursor getDiffCursor(long from, long to);
+        ModelDiffCursor getDiffCursor(Version from, Version to);
 
         <T extends ModelStoreAdapter> Optional<T> tryGetAdapter(Class<? extends T> adapterType);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
index c5475a1a..c2ad9257 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
@@ -8,6 +8,7 @@ package tools.refinery.store.model.internal;
 import tools.refinery.store.adapter.AdapterUtils;
 import tools.refinery.store.adapter.ModelAdapter;
 import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.model.*;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
@@ -17,21 +18,21 @@ import java.util.*;
 
 public class ModelImpl implements Model {
         private final ModelStore store;
-        private long state;
-        private Map<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations;
+        private Version state;
+        private LinkedHashMap<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations;
         private final List<ModelAdapter> adapters;
         private final List<ModelListener> listeners = new ArrayList<>();
         private boolean uncommittedChanges;
         private ModelAction pendingAction = ModelAction.NONE;
-        private long restoringToState = NO_STATE_ID;
+        private Version restoringToState = null;
 
-        ModelImpl(ModelStore store, long state, int adapterCount) {
+        ModelImpl(ModelStore store, Version state, int adapterCount) {
                 this.store = store;
                 this.state = state;
                 adapters = new ArrayList<>(adapterCount);
         }
 
-        void setInterpretations(Map<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations) {
+        void setInterpretations(LinkedHashMap<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations) {
                 this.interpretations = interpretations;
         }
 
@@ -41,7 +42,7 @@ public class ModelImpl implements Model {
         }
 
         @Override
-        public long getState() {
+        public Version getState() {
                 return state;
         }
 
@@ -57,7 +58,7 @@ public class ModelImpl implements Model {
         }
 
         @Override
-        public ModelDiffCursor getDiffCursor(long to) {
+        public ModelDiffCursor getDiffCursor(Version to) {
                 var diffCursors = new HashMap<AnySymbol, DiffCursor<Tuple, ?>>(interpretations.size());
                 for (var entry : interpretations.entrySet()) {
                         diffCursors.put(entry.getKey(), entry.getValue().getDiffCursor(to));
@@ -65,7 +66,7 @@ public class ModelImpl implements Model {
                 return new ModelDiffCursor(diffCursors);
         }
 
-        private void setState(long state) {
+        private void setState(Version state) {
                 this.state = state;
                 uncommittedChanges = false;
         }
@@ -82,11 +83,11 @@ public class ModelImpl implements Model {
         }
 
         private boolean hasPendingAction() {
-                return pendingAction != ModelAction.NONE || restoringToState != NO_STATE_ID;
+                return pendingAction != ModelAction.NONE || restoringToState != null;
         }
 
         @Override
-        public long commit() {
+        public Version commit() {
                 if (hasPendingAction()) {
                         throw pendingActionError("commit");
                 }
@@ -94,43 +95,40 @@ public class ModelImpl implements Model {
                 try {
                         int listenerCount = listeners.size();
                         int i = listenerCount;
-                        long version = 0;
+
+                        // Before commit message to listeners
                         while (i > 0) {
                                 i--;
                                 listeners.get(i).beforeCommit();
                         }
-                        boolean versionSet = false;
-                        for (var interpretation : interpretations.values()) {
-                                long newVersion = interpretation.commit();
-                                if (versionSet) {
-                                        if (version != newVersion) {
-                                                throw new IllegalStateException("Interpretations in model have different versions (%d and %d)"
-                                                                .formatted(version, newVersion));
-                                        }
-                                } else {
-                                        version = newVersion;
-                                        versionSet = true;
-                                }
+
+                        // Doing the commit on the interpretations
+                        Version[] interpretationVersions = new Version[interpretations.size()];
+                        int j = 0;
+                        for(var interpretationEntry : interpretations.entrySet()) {
+                                interpretationVersions[j++] = interpretationEntry.getValue().commit();
                         }
-                        setState(version);
+                        ModelVersion modelVersion = new ModelVersion(interpretationVersions);
+                        setState(modelVersion);
+
+                        // After commit message to listeners
                         while (i < listenerCount) {
                                 listeners.get(i).afterCommit();
                                 i++;
                         }
-                        return version;
+
+                        return modelVersion;
                 } finally {
                         pendingAction = ModelAction.NONE;
                 }
         }
 
         @Override
-        public void restore(long version) {
+        public void restore(Version version) {
                 if (hasPendingAction()) {
-                        throw pendingActionError("restore to %d".formatted(version));
-                }
-                if (!store.getStates().contains(version)) {
-                        throw new IllegalArgumentException("Store does not contain state %d".formatted(version));
+                        throw pendingActionError("restore to %s".formatted(version));
                 }
+
                 pendingAction = ModelAction.RESTORE;
                 restoringToState = version;
                 try {
@@ -140,9 +138,11 @@ public class ModelImpl implements Model {
                                 i--;
                                 listeners.get(i).beforeRestore(version);
                         }
+                        int j = 0;
                         for (var interpretation : interpretations.values()) {
-                                interpretation.restore(version);
+                                interpretation.restore(ModelVersion.getInternalVersion(version,j++));
                         }
+
                         setState(version);
                         while (i < listenerCount) {
                                 listeners.get(i).afterRestore();
@@ -150,7 +150,7 @@ public class ModelImpl implements Model {
                         }
                 } finally {
                         pendingAction = ModelAction.NONE;
-                        restoringToState = NO_STATE_ID;
+                        restoringToState = null;
                 }
         }
 
@@ -159,7 +159,7 @@ public class ModelImpl implements Model {
                         case NONE -> throw new IllegalArgumentException("Trying to throw pending action error when there is no " +
                                         "pending action");
                         case COMMIT -> "commit";
-                        case RESTORE -> "restore to %d".formatted(restoringToState);
+                        case RESTORE -> "restore to %s".formatted(restoringToState);
                 };
                 return new IllegalStateException("Cannot %s due to pending %s".formatted(currentActionName, pendingActionName));
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
index 2cc7b19c..65fa8d24 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
@@ -19,8 +19,8 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.*;
 
 public class ModelStoreBuilderImpl implements ModelStoreBuilder {
-        private final Set<AnySymbol> allSymbols = new HashSet<>();
-        private final Map<SymbolEquivalenceClass<?>, List<AnySymbol>> equivalenceClasses = new HashMap<>();
+        private final LinkedHashSet<AnySymbol> allSymbols = new LinkedHashSet<>();
+        private final LinkedHashMap<SymbolEquivalenceClass<?>, List<AnySymbol>> equivalenceClasses = new LinkedHashMap<>();
         private final List<ModelAdapterBuilder> adapters = new ArrayList<>();
 
         @Override
@@ -59,7 +59,7 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
 
         @Override
         public ModelStore build() {
-                var stores = new HashMap<AnySymbol, VersionedMapStore<Tuple, ?>>(allSymbols.size());
+                var stores = new LinkedHashMap<AnySymbol, VersionedMapStore<Tuple, ?>>(allSymbols.size());
                 for (var entry : equivalenceClasses.entrySet()) {
                         createStores(stores, entry.getKey(), entry.getValue());
                 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
index 60b735e6..a320a618 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
@@ -8,8 +8,8 @@ package tools.refinery.store.model.internal;
 import tools.refinery.store.adapter.AdapterUtils;
 import tools.refinery.store.adapter.ModelStoreAdapter;
 import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.Version;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelDiffCursor;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.representation.AnySymbol;
@@ -18,10 +18,10 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.*;
 
 public class ModelStoreImpl implements ModelStore {
-        private final Map<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores;
+        private final LinkedHashMap<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores;
         private final List<ModelStoreAdapter> adapters;
 
-        ModelStoreImpl(Map<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores, int adapterCount) {
+        ModelStoreImpl(LinkedHashMap<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores, int adapterCount) {
                 this.stores = stores;
                 adapters = new ArrayList<>(adapterCount);
         }
@@ -31,14 +31,14 @@ public class ModelStoreImpl implements ModelStore {
                 return Collections.unmodifiableCollection(stores.keySet());
         }
 
-        private ModelImpl createModelWithoutInterpretations(long state) {
+        private ModelImpl createModelWithoutInterpretations(Version state) {
                 return new ModelImpl(this, state, adapters.size());
         }
 
         @Override
         public ModelImpl createEmptyModel() {
-                var model = createModelWithoutInterpretations(Model.NO_STATE_ID);
-                var interpretations = new HashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
+                var model = createModelWithoutInterpretations(null);
+                var interpretations = new LinkedHashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
                 for (var entry : this.stores.entrySet()) {
                         var symbol = entry.getKey();
                         interpretations.put(symbol, VersionedInterpretation.of(model, symbol, entry.getValue()));
@@ -49,13 +49,21 @@ public class ModelStoreImpl implements ModelStore {
         }
 
         @Override
-        public synchronized ModelImpl createModelForState(long state) {
+        public synchronized ModelImpl createModelForState(Version state) {
                 var model = createModelWithoutInterpretations(state);
-                var interpretations = new HashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
+                var interpretations = new LinkedHashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
+
+                int i=0;
                 for (var entry : this.stores.entrySet()) {
                         var symbol = entry.getKey();
-                        interpretations.put(symbol, VersionedInterpretation.of(model, symbol, entry.getValue(), state));
+                        interpretations.put(symbol,
+                                        VersionedInterpretation.of(
+                                                        model,
+                                                        symbol,
+                                                        entry.getValue(),
+                                                        ModelVersion.getInternalVersion(state,i++)));
                 }
+
                 model.setInterpretations(interpretations);
                 adaptModel(model);
                 return model;
@@ -69,16 +77,7 @@ public class ModelStoreImpl implements ModelStore {
         }
 
         @Override
-        public synchronized Set<Long> getStates() {
-                var iterator = stores.values().iterator();
-                if (iterator.hasNext()) {
-                        return Set.copyOf(iterator.next().getStates());
-                }
-                return Set.of(0L);
-        }
-
-        @Override
-        public synchronized ModelDiffCursor getDiffCursor(long from, long to) {
+        public synchronized ModelDiffCursor getDiffCursor(Version from, Version to) {
                 var diffCursors = new HashMap<AnySymbol, DiffCursor<?, ?>>();
                 for (var entry : stores.entrySet()) {
                         var representation = entry.getKey();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java
new file mode 100644
index 00000000..cf3b7fc6
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java
@@ -0,0 +1,39 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.map.Version;
+
+import java.util.Arrays;
+
+public record ModelVersion(Version[] mapVersions) implements Version{
+
+        public static Version getInternalVersion(Version modelVersion, int interpretationIndex) {
+                return ((ModelVersion)modelVersion).mapVersions()[interpretationIndex];
+        }
+
+        @Override
+        public int hashCode() {
+                return Arrays.hashCode(mapVersions);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+
+                ModelVersion that = (ModelVersion) o;
+
+                return Arrays.equals(mapVersions, that.mapVersions);
+        }
+
+        @Override
+        public String toString() {
+                return "ModelVersion{" +
+                                "mapVersions=" + Arrays.toString(mapVersions) +
+                                '}';
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
index 404be65f..76e3baea 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
@@ -5,10 +5,7 @@
  */
 package tools.refinery.store.model.internal;
 
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.map.DiffCursor;
-import tools.refinery.store.map.VersionedMap;
-import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.*;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.InterpretationListener;
 import tools.refinery.store.model.Model;
@@ -110,15 +107,14 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
         }
 
         @Override
-        public DiffCursor<Tuple, T> getDiffCursor(long to) {
+        public DiffCursor<Tuple, T> getDiffCursor(Version to) {
                 return map.getDiffCursor(to);
         }
 
-        public long commit() {
+        Version commit() {
                 return map.commit();
         }
-
-        public void restore(long state) {
+        void restore(Version state) {
                 if (!restoreListeners.isEmpty()) {
                         var diffCursor = getDiffCursor(state);
                         while (diffCursor.move()) {
@@ -150,7 +146,7 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
         }
 
         static <T> VersionedInterpretation<T> of(ModelImpl model, AnySymbol symbol, VersionedMapStore<Tuple, T> store,
-                                                                                         long state) {
+                                                                                         Version state) {
                 @SuppressWarnings("unchecked")
                 var typedSymbol = (Symbol<T>) symbol;
                 var map = store.createMap(state);