diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index 834a6019..8d695821 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -26,13 +26,13 @@ jobs:
       TOKEN: "${{secrets.ALLREP_TOKEN}}"
       CI: "true"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - uses: actions/setup-java@v3
         with:
-          java-version: 11
+          java-version: 17
           distribution: zulu
 
       ################################################################################
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 12cd94d2..4f82f21f 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -30,7 +30,7 @@
   <component name="NodePackageJsonFileManager">
     <packageJsonPaths />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="11" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK" />
   <component name="SvnConfiguration" maxAnnotateRevisions="500">
     <option name="USER" value="" />
     <option name="PASSWORD" value="" />
diff --git a/build.gradle.kts b/build.gradle.kts
index c3c905d3..dfa54924 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -23,8 +23,8 @@ plugins {
     eclipse
 }
 dependencies {
-    implementation("org.modelingvalue:immutable-collections:3.1.0-BRANCHED")
-    implementation("org.modelingvalue:mvg-json:3.1.0-BRANCHED")
+    implementation("org.modelingvalue:immutable-collections:4.0.0-BRANCHED")
+    implementation("org.modelingvalue:mvg-json:4.0.0-BRANCHED")
 }
 publishing {
     publications {
diff --git a/gradle.properties b/gradle.properties
index a311c8b8..3f2a56ce 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -16,5 +16,5 @@
 # suppress inspection "UnusedProperty" for whole file
 group        = org.modelingvalue
 artifact     = dclare
-version      = 3.1.0
-version_java = 11
+version      = 4.0.0
+version_java = 17
diff --git a/src/main/java/org/modelingvalue/dclare/AbstractDerivationTransaction.java b/src/main/java/org/modelingvalue/dclare/AbstractDerivationTransaction.java
index 18fae080..29fe4d31 100644
--- a/src/main/java/org/modelingvalue/dclare/AbstractDerivationTransaction.java
+++ b/src/main/java/org/modelingvalue/dclare/AbstractDerivationTransaction.java
@@ -59,7 +59,12 @@ public <R> R derive(Supplier<R> action, State state, ConstantState memoization)
     }
 
     @SuppressWarnings("rawtypes")
-    protected <O, T> boolean doDerive(O object, Getable<O, T> getable) {
+    protected <O, T> boolean doDeriveGet(O object, Getable<O, T> getable, T nonDerived) {
+        return doDeriveSet(object, getable);
+    }
+
+    @SuppressWarnings("rawtypes")
+    protected <O, T> boolean doDeriveSet(O object, Getable<O, T> getable) {
         return object instanceof Mutable && getable instanceof Observed && DERIVE.get();
     }
 
@@ -81,7 +86,7 @@ protected <O, T> T current(O object, Getable<O, T> getable) {
 
     @SuppressWarnings("rawtypes")
     private <O, T> T derive(O object, Getable<O, T> getable, T nonDerived) {
-        if (doDerive(object, getable)) {
+        if (doDeriveGet(object, getable, nonDerived)) {
             Observed<O, T> observed = (Observed<O, T>) getable;
             ConstantState mem = memoization(object);
             Constant<O, T> constant = observed.constant();
@@ -103,7 +108,7 @@ private <O, T> T derive(O object, Getable<O, T> getable, T nonDerived) {
                         }
                         INDENT.run(INDENT.get() + 1, () -> DERIVED.run(newDerived, () -> {
                             int i = 0;
-                            Set<Observer> observers = ((Mutable) object).dAllDerivers(observed).toSet();
+                            Set<Observer> observers = ((Mutable) object).dAllDerivers(observed).asSet();
                             for (Observer observer : observers.filter(Observer::anonymous)) {
                                 runDeriver((Mutable) object, observed, observer, ++i);
                             }
@@ -127,7 +132,7 @@ private <O, T> T derive(O object, Getable<O, T> getable, T nonDerived) {
     }
 
     @SuppressWarnings({"rawtypes", "unchecked"})
-    private void runDeriver(Mutable mutable, Observed observed, Observer observer, int i) {
+    protected void runDeriver(Mutable mutable, Observed observed, Observer observer, int i) {
         if (isTraceDerivation(mutable, observed)) {
             runNonDeriving(() -> System.err.println(tracePre(mutable) + String.format(">>%d> ", i) + mutable + "." + observer + "()"));
         }
@@ -161,12 +166,12 @@ public void runNonDeriving(Runnable action) {
     @SuppressWarnings({"unchecked", "rawtypes"})
     @Override
     public <O, T> T set(O object, Setable<O, T> setable, T post) {
-        if (doDerive(object, setable)) {
+        if (doDeriveSet(object, setable)) {
             ConstantState mem = memoization(object);
             Constant<O, T> constant = setable.constant();
             T pre = mem.isSet(this, object, constant) ? mem.get(this, object, constant) : getNonDerived(object, setable);
             T result = match(mem, setable, pre, post);
-            mem.set(this, object, constant, result, true);
+            setInMemoization(mem, object, setable, result);
             if (isTraceDerivation(object, setable)) {
                 runNonDeriving(() -> {
                     Pair<Mutable, Observer> deriver = DERIVER.get();
@@ -175,7 +180,7 @@ public <O, T> T set(O object, Setable<O, T> setable, T post) {
             }
             if (setable.containment()) {
                 Setable.<T, Mutable> diff(pre, result, added -> {
-                    mem.set(this, added, Mutable.D_PARENT_CONTAINING.constant(), Pair.of((Mutable) object, (Setable<Mutable, ?>) setable), true);
+                    setInMemoization(mem, added, Mutable.D_PARENT_CONTAINING, Pair.of((Mutable) object, (Setable<Mutable, ?>) setable));
                 }, removed -> {
                 });
             }
@@ -188,27 +193,27 @@ Setable.<T, Mutable> diff(pre, result, added -> {
     }
 
     private <T, O> T match(ConstantState mem, Setable<O, T> setable, T pre, T post) {
-        List<Newable> posts = setable.collection(post).filter(Newable.class).distinct().toList();
+        List<Newable> posts = setable.collection(post).filter(Newable.class).distinct().asList();
         if (!posts.isEmpty()) {
-            List<Newable> pres = setable.collection(pre).filter(Newable.class).exclude(posts::contains).distinct().toList();
+            List<Newable> pres = setable.collection(pre).filter(Newable.class).exclude(posts::contains).distinct().asList();
             if (!pres.isEmpty()) {
                 for (Newable po : posts) {
-                    Construction poInit = Newable.D_INITIAL_CONSTRUCTION.get(po);
+                    Construction poInit = Mutable.D_INITIAL_CONSTRUCTION.get(po);
                     if (poInit.isDerived() && mem.isSet(this, po, Newable.D_ALL_DERIVATIONS.constant())) {
                         for (Newable pr : pres) {
-                            Construction preInit = Newable.D_INITIAL_CONSTRUCTION.get(pr);
+                            Construction preInit = Mutable.D_INITIAL_CONSTRUCTION.get(pr);
                             if (preInit.isDirect() && po.dNewableType().equals(pr.dNewableType()) && Objects.equals(po.dIdentity(), pr.dIdentity())) {
                                 pres = pres.remove(pr);
                                 post = replace(post, po, pr);
-                                mem.set(this, pr, Newable.D_ALL_DERIVATIONS.constant(), mem.get(this, po, Newable.D_ALL_DERIVATIONS.constant()), true);
+                                setInMemoization(mem, pr, Mutable.D_ALL_DERIVATIONS, mem.get(this, po, Newable.D_ALL_DERIVATIONS.constant()));
                             }
                         }
                     } else if (poInit.isDirect()) {
                         for (Newable pr : pres) {
-                            Construction preInit = Newable.D_INITIAL_CONSTRUCTION.get(pr);
+                            Construction preInit = Mutable.D_INITIAL_CONSTRUCTION.get(pr);
                             if (preInit.isDerived() && mem.isSet(this, pr, Newable.D_ALL_DERIVATIONS.constant()) && po.dNewableType().equals(pr.dNewableType()) && Objects.equals(po.dIdentity(), pr.dIdentity())) {
                                 pres = pres.remove(pr);
-                                mem.set(this, po, Newable.D_ALL_DERIVATIONS.constant(), mem.get(this, pr, Newable.D_ALL_DERIVATIONS.constant()), true);
+                                setInMemoization(mem, po, Mutable.D_ALL_DERIVATIONS, mem.get(this, pr, Newable.D_ALL_DERIVATIONS.constant()));
                             }
                         }
                     }
@@ -239,11 +244,15 @@ public <O extends Mutable> O construct(Reason reason, Supplier<O> supplier) {
         Pair<Mutable, Observer> deriver = DERIVER.get();
         O result = supplier.get();
         Construction cons = Construction.of(deriver.a(), deriver.b(), reason);
-        memoization(deriver.a()).set(this, result, Newable.D_ALL_DERIVATIONS.constant(), Newable.D_ALL_DERIVATIONS.getDefault(result).add(cons), false);
-        Newable.D_INITIAL_CONSTRUCTION.force(result, cons);
+        setInMemoization(memoization(deriver.a()), result, Newable.D_ALL_DERIVATIONS, Newable.D_ALL_DERIVATIONS.getDefault(result).add(cons));
+        Mutable.D_INITIAL_CONSTRUCTION.force(result, cons);
         return result;
     }
 
+    protected <T, O> void setInMemoization(ConstantState mem, O object, Setable<O, T> setable, T result) {
+        mem.set(this, object, setable.constant(), result, true);
+    }
+
     protected <O> ConstantState memoization(O object) {
         return object instanceof Mutable ? ((Mutable) object).dMemoization(this) : memoization();
     }
@@ -254,7 +263,7 @@ public <O> ConstantState memoization() {
 
     @SuppressWarnings("rawtypes")
     protected <O> boolean isTraceDerivation(O object, Setable setable) {
-        return !setable.isPlumbing() && universeTransaction().getConfig().isTraceDerivation();
+        return (setable == null || !setable.isPlumbing()) && universeTransaction().getConfig().isTraceDerivation();
     }
 
     private <O> String tracePre(O object) {
diff --git a/src/main/java/org/modelingvalue/dclare/Action.java b/src/main/java/org/modelingvalue/dclare/Action.java
index 5d7cf49e..e0eaeaa0 100644
--- a/src/main/java/org/modelingvalue/dclare/Action.java
+++ b/src/main/java/org/modelingvalue/dclare/Action.java
@@ -24,7 +24,7 @@ public static <M extends Mutable> Action<M> of(Object id) {
         }, Priority.one);
     }
 
-    public static <M extends Mutable> Action<M> of(Object id, Consumer<M> action, LeafModifier... modifiers) {
+    public static <M extends Mutable> Action<M> of(Object id, Consumer<M> action, LeafModifier<?>... modifiers) {
         return new Action<>(id, action, modifiers);
     }
 
@@ -33,13 +33,13 @@ public static <M extends Mutable> Action<M> of(Object id, Consumer<M> action, Le
     private final boolean     preserved;
     private final boolean     read;
 
-    protected Action(Object id, Consumer<O> action, LeafModifier... modifiers) {
+    protected Action(Object id, Consumer<O> action, LeafModifier<?>... modifiers) {
         super(id, modifiers);
         this.action = action;
-        Direction dir = FeatureModifier.ofClass(Direction.class, modifiers);
+        Direction dir = getModifier(Direction.class);
         this.direction = dir == null ? Direction.DEFAULT : dir;
-        this.preserved = LeafModifier.preserved.in(modifiers);
-        this.read = LeafModifier.read.in(modifiers);
+        this.preserved = hasModifier(LeafModifier.preserved);
+        this.read = hasModifier(LeafModifier.read);
     }
 
     @Override
@@ -69,7 +69,7 @@ public ActionTransaction newTransaction(UniverseTransaction universeTransaction)
         return new ActionTransaction(universeTransaction);
     }
 
-    protected Direction direction() {
+    public Direction direction() {
         return direction;
     }
 
diff --git a/src/main/java/org/modelingvalue/dclare/ActionTransaction.java b/src/main/java/org/modelingvalue/dclare/ActionTransaction.java
index ba5e4b0d..5c21fdb6 100644
--- a/src/main/java/org/modelingvalue/dclare/ActionTransaction.java
+++ b/src/main/java/org/modelingvalue/dclare/ActionTransaction.java
@@ -33,12 +33,9 @@
 import org.modelingvalue.dclare.ex.TransactionException;
 
 public class ActionTransaction extends LeafTransaction implements StateMergeHandler {
-
-    private static final BiFunction<TransactionId, TransactionId, TransactionId> HIGHEST      = (b, a) -> b == null || b.number() < a.number() ? a : b;
-
-    private final CurrentState                                                   currentState = new CurrentState();
-    private State                                                                preState;
-    private State                                                                postState;
+    private final CurrentState currentState = new CurrentState();
+    private State              preState;
+    private State              postState;
 
     protected ActionTransaction(UniverseTransaction universeTransaction) {
         super(universeTransaction);
@@ -53,7 +50,7 @@ protected void run(State pre, UniverseTransaction universeTransaction) {
         ((Action<Mutable>) action()).run(mutable());
     }
 
-    @SuppressWarnings({"rawtypes", "unchecked"})
+    @SuppressWarnings("rawtypes")
     @Override
     protected final State run(State pre) {
         TraceTimer.traceBegin(traceId());
@@ -64,11 +61,9 @@ protected final State run(State pre) {
                 run(pre, universeTransaction());
                 if (universeTransaction().getConfig().isTraceActions()) {
                     postState = currentState.merge();
-                    Map<Object, Map<Setable, Pair<Object, Object>>> diff = preState.diff(postState, o -> o instanceof Mutable, s -> s instanceof Observed && !s.isPlumbing()).toMap(e -> e);
+                    Map<Object, Map<Setable, Pair<Object, Object>>> diff = preState.diff(postState, o -> o instanceof Mutable, s -> s instanceof Observed /* && !s.isPlumbing() */).asMap(e -> e);
                     if (!diff.isEmpty()) {
-                        runNonObserving(() -> {
-                            System.err.println(DclareTrace.getLineStart("DCLARE", this) + mutable() + "." + action() + " (" + postState.shortDiffString(diff, mutable()) + ")");
-                        });
+                        runNonObserving(() -> System.err.println(DclareTrace.getLineStart("DCLARE", this) + mutable() + "." + action() + " (" + postState.shortDiffString(diff, mutable()) + ")"));
                     }
                 } else {
                     postState = currentState.result();
@@ -156,6 +151,10 @@ protected <T, O> void set(O object, Setable<O, T> property, T pre, T post) {
         }
     }
 
+    protected void setState(State state) {
+        currentState.set(state);
+    }
+
     @SuppressWarnings({"rawtypes", "unchecked", "RedundantSuppression"})
     @Override
     protected <O, T> void changed(O object, Setable<O, T> setable, T preValue, T postValue) {
@@ -178,22 +177,21 @@ private <O, T> void trigger(O object, Observed<O, T> observed) {
                 if (!action().equals(observer) || !source.equals(target)) {
                     trigger(target, observer, observer.initPriority());
                     if (universeTransaction().getConfig().isTraceMutable()) {
-                        runNonObserving(() -> {
-                            System.err.println(DclareTrace.getLineStart("DCLARE", this) + mutable() + "." + action() + " (TRIGGER " + target + "." + observer + ")");
-                        });
+                        runNonObserving(() -> System.err.println(DclareTrace.getLineStart("DCLARE", this) + mutable() + "." + action() + " (TRIGGER " + target + "." + observer + ")"));
                     }
                 }
             }
         }
     }
 
-    @SuppressWarnings("rawtypes")
-    private final <O, T> void setChanged(O object, Setable<O, T> setable, T postValue) {
+    private <O, T> void setChanged(O object, Setable<O, T> setable, T postValue) {
         TransactionId txid = action().preserved() ? universeTransaction().setPreserved(object, setable, postValue, action()) : current().transactionId();
         for (Mutable changed = (Mutable) object; changed != null && !(changed instanceof Universe); changed = dParent(changed)) {
-            TransactionId old = set(changed, Mutable.D_CHANGE_ID, HIGHEST, txid);
-            if (old != null && old.number() >= txid.number()) {
+            TransactionId old = current(changed, Mutable.D_CHANGE_ID);
+            if (old != null && txid.number() <= old.number()) {
                 break;
+            } else {
+                set(changed, Mutable.D_CHANGE_ID, txid);
             }
         }
     }
@@ -203,7 +201,6 @@ private final class CurrentState extends Concurrent<State> {
         protected State merge(State base, State[] branches, int length) {
             return base.merge(ActionTransaction.this, branches, length);
         }
-
     }
 
     @SuppressWarnings("rawtypes")
@@ -239,9 +236,8 @@ protected String getCurrentTypeForTrace() {
         return "AC";
     }
 
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"unchecked", "unused"})
     public void retrigger(Priority prio) {
         trigger(mutable(), (Action<Mutable>) action(), prio);
     }
-
 }
diff --git a/src/main/java/org/modelingvalue/dclare/Constant.java b/src/main/java/org/modelingvalue/dclare/Constant.java
index e6061def..f1626aab 100644
--- a/src/main/java/org/modelingvalue/dclare/Constant.java
+++ b/src/main/java/org/modelingvalue/dclare/Constant.java
@@ -31,41 +31,41 @@ public class Constant<O, T> extends Setable<O, T> {
 
     public static final Context<Pair<Object, Constant<?, ?>>> DERIVED = Context.of(null);
 
-    public static <C, V> Constant<C, V> of(Object id, V def, SetableModifier... modifiers) {
+    public static <C, V> Constant<C, V> of(Object id, V def, SetableModifier<?>... modifiers) {
         return new Constant<>(id, o -> def, null, null, null, null, modifiers);
     }
 
-    public static <C, V> Constant<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier... modifiers) {
+    public static <C, V> Constant<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier<?>... modifiers) {
         return new Constant<>(id, o -> def, null, null, null, changed, modifiers);
     }
 
-    public static <C, V> Constant<C, V> of(Object id, Function<C, V> deriver, SetableModifier... modifiers) {
+    public static <C, V> Constant<C, V> of(Object id, Function<C, V> deriver, SetableModifier<?>... modifiers) {
         return new Constant<>(id, null, null, null, deriver, null, modifiers);
     }
 
-    public static <C, V> Constant<C, V> of(Object id, V def, Function<C, V> deriver, SetableModifier... modifiers) {
+    public static <C, V> Constant<C, V> of(Object id, V def, Function<C, V> deriver, SetableModifier<?>... modifiers) {
         return new Constant<>(id, o -> def, null, null, deriver, null, modifiers);
     }
 
-    public static <C, V> Constant<C, V> of(Object id, Function<C, V> deriver, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier... modifiers) {
+    public static <C, V> Constant<C, V> of(Object id, Function<C, V> deriver, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier<?>... modifiers) {
         return new Constant<>(id, null, null, null, deriver, changed, modifiers);
     }
 
-    public static <C, V> Constant<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, Function<C, V> deriver, SetableModifier... modifiers) {
+    public static <C, V> Constant<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, Function<C, V> deriver, SetableModifier<?>... modifiers) {
         return new Constant<>(id, o -> def, opposite, null, deriver, null, modifiers);
     }
 
-    public static <C, V> Constant<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, Function<C, V> deriver, SetableModifier... modifiers) {
+    public static <C, V> Constant<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, Function<C, V> deriver, SetableModifier<?>... modifiers) {
         return new Constant<>(id, o -> def, opposite, scope, deriver, null, modifiers);
     }
 
     private final Function<O, T> deriver;
     private final boolean        durable;
 
-    protected Constant(Object id, Function<O, T> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<O, Set<?>>> scope, Function<O, T> deriver, QuadConsumer<LeafTransaction, O, T, T> changed, SetableModifier... modifiers) {
+    protected Constant(Object id, Function<O, T> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<O, Set<?>>> scope, Function<O, T> deriver, QuadConsumer<LeafTransaction, O, T, T> changed, SetableModifier<?>... modifiers) {
         super(id, def, opposite, scope, changed, modifiers);
         this.deriver = deriver;
-        this.durable = SetableModifier.durable.in(modifiers);
+        this.durable = hasModifier(CoreSetableModifier.durable);
     }
 
     public Function<O, T> deriver() {
diff --git a/src/main/java/org/modelingvalue/dclare/Construction.java b/src/main/java/org/modelingvalue/dclare/Construction.java
index 4c983c40..2b9c64dd 100644
--- a/src/main/java/org/modelingvalue/dclare/Construction.java
+++ b/src/main/java/org/modelingvalue/dclare/Construction.java
@@ -15,11 +15,11 @@
 
 package org.modelingvalue.dclare;
 
-import static org.modelingvalue.dclare.SetableModifier.durable;
-
 import org.modelingvalue.collections.Set;
 import org.modelingvalue.collections.util.IdentifiedByArray;
 
+import static org.modelingvalue.dclare.CoreSetableModifier.durable;
+
 @SuppressWarnings("rawtypes")
 public class Construction extends IdentifiedByArray {
 
@@ -55,7 +55,7 @@ public Reason reason() {
     }
 
     public boolean hasSource(Mutable source) {
-        return isDerived() ? reason().hasSource(object(), source) : false;
+        return isDerived() && reason().hasSource(object(), source);
     }
 
     @Override
@@ -112,7 +112,7 @@ private boolean hasSource(Mutable thiz, Mutable source) {
             for (int i = 0; i < size(); i++) {
                 Object v = get(thiz, i);
                 if (v instanceof Mutable) {
-                    if (((Mutable) v).equals(source)) {
+                    if (v.equals(source)) {
                         return true;
                     }
                 }
diff --git a/src/main/java/org/modelingvalue/dclare/CoreSetableModifier.java b/src/main/java/org/modelingvalue/dclare/CoreSetableModifier.java
new file mode 100644
index 00000000..2eec9219
--- /dev/null
+++ b/src/main/java/org/modelingvalue/dclare/CoreSetableModifier.java
@@ -0,0 +1,29 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// (C) Copyright 2018-2023 Modeling Value Group B.V. (http://modelingvalue.org)                                        ~
+//                                                                                                                     ~
+// Licensed under the GNU Lesser General Public License v3.0 (the 'License'). You may not use this file except in      ~
+// compliance with the License. You may obtain a copy of the License at: https://choosealicense.com/licenses/lgpl-3.0  ~
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on ~
+// an 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  ~
+// specific language governing permissions and limitations under the License.                                          ~
+//                                                                                                                     ~
+// Maintainers:                                                                                                        ~
+//     Wim Bast, Tom Brus, Ronald Krijgsheld                                                                           ~
+// Contributors:                                                                                                       ~
+//     Arjan Kok, Carel Bast                                                                                           ~
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+package org.modelingvalue.dclare;
+
+public enum CoreSetableModifier implements SetableModifier<SetableModifier<?>> {
+    symmetricOpposite,
+    containment,
+    mandatory,
+    synthetic,
+    plumbing,
+    durable,
+    doNotMerge,
+    orphansAllowed,
+    preserved,
+    doNotClear;
+}
diff --git a/src/main/java/org/modelingvalue/dclare/Derivation.java b/src/main/java/org/modelingvalue/dclare/Derivation.java
index fc7cf975..fc937b3f 100644
--- a/src/main/java/org/modelingvalue/dclare/Derivation.java
+++ b/src/main/java/org/modelingvalue/dclare/Derivation.java
@@ -17,7 +17,7 @@
 
 public class Derivation extends ReadOnly {
 
-    protected Derivation(Object id, LeafModifier... modifiers) {
+    protected Derivation(Object id, LeafModifier<?>... modifiers) {
         super(id, modifiers);
     }
 
diff --git a/src/main/java/org/modelingvalue/dclare/Direction.java b/src/main/java/org/modelingvalue/dclare/Direction.java
index 4ba155c6..567830c2 100644
--- a/src/main/java/org/modelingvalue/dclare/Direction.java
+++ b/src/main/java/org/modelingvalue/dclare/Direction.java
@@ -21,14 +21,22 @@
 import org.modelingvalue.collections.Set;
 import org.modelingvalue.collections.util.Internable;
 
-public interface Direction extends LeafModifier, Internable {
+public interface Direction extends LeafModifier<Direction>, SetableModifier<Direction>, Internable {
 
     static Direction of(Object id, Direction... opposites) {
-        return new DirectionImpl(id, opposites);
+        return new DirectionImpl(id, false, opposites);
     }
 
     static Direction of(Object id, Supplier<Set<Direction>> oppositeSupplier) {
-        return new DirectionImpl(id, oppositeSupplier);
+        return new DirectionImpl(id, false, oppositeSupplier);
+    }
+
+    static Direction of(Object id, boolean lazy, Direction... opposites) {
+        return new DirectionImpl(id, lazy, opposites);
+    }
+
+    static Direction of(Object id, boolean lazy, Supplier<Set<Direction>> oppositeSupplier) {
+        return new DirectionImpl(id, lazy, oppositeSupplier);
     }
 
     Direction DEFAULT = new Direction() {
@@ -41,26 +49,40 @@ public String toString() {
         public Set<Direction> opposites() {
             return Set.of();
         }
+
+        @Override
+        public boolean isLazy() {
+            return false;
+        }
     };
 
     Set<Direction> opposites();
 
+    boolean isLazy();
+
     static final class DirectionImpl implements Direction {
 
         private final Object                   id;
+        private final boolean                  lazy;
         private final Supplier<Set<Direction>> oppositeSupplier;
 
         private Set<Direction>                 opposites = null;
 
-        private DirectionImpl(Object id, Direction... opposites) {
-            this(id, () -> Collection.of(opposites).toSet());
+        private DirectionImpl(Object id, boolean lazy, Direction... opposites) {
+            this(id, lazy, () -> Collection.of(opposites).asSet());
         }
 
-        private DirectionImpl(Object id, Supplier<Set<Direction>> oppositeSupplier) {
+        private DirectionImpl(Object id, boolean lazy, Supplier<Set<Direction>> oppositeSupplier) {
             this.id = id;
+            this.lazy = lazy;
             this.oppositeSupplier = oppositeSupplier;
         }
 
+        @Override
+        public boolean isLazy() {
+            return lazy;
+        }
+
         @Override
         public boolean equals(Object obj) {
             return obj instanceof Direction.DirectionImpl && ((Direction.DirectionImpl) obj).id.equals(id);
diff --git a/src/main/java/org/modelingvalue/dclare/FeatureModifier.java b/src/main/java/org/modelingvalue/dclare/FeatureModifier.java
index cb6ab7d2..261142d7 100644
--- a/src/main/java/org/modelingvalue/dclare/FeatureModifier.java
+++ b/src/main/java/org/modelingvalue/dclare/FeatureModifier.java
@@ -17,6 +17,8 @@
 
 import java.util.Arrays;
 
+import org.modelingvalue.collections.Collection;
+
 /**
  * this is a marker interface
  */
@@ -33,17 +35,8 @@ default M ifnot(boolean b) {
         return b ? null : (M) this;
     }
 
-    default boolean in(M[] modifiers) {
-        for (M m : modifiers) {
-            if (this == m) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     @SuppressWarnings("unchecked")
-    static <C extends M, M extends FeatureModifier> C ofClass(Class<C> cls, M[] modifiers) {
+    static <C extends M, M extends FeatureModifier> C ofClass(Class<C> cls, Collection<M> modifiers) {
         for (M m : modifiers) {
             if (cls.isInstance(m)) {
                 return (C) m;
diff --git a/src/main/java/org/modelingvalue/dclare/Getable.java b/src/main/java/org/modelingvalue/dclare/Getable.java
index 546bf7aa..95c89fe4 100644
--- a/src/main/java/org/modelingvalue/dclare/Getable.java
+++ b/src/main/java/org/modelingvalue/dclare/Getable.java
@@ -107,7 +107,7 @@ public <E> Collection<E> collection(T v) {
 
     @SuppressWarnings("unchecked")
     public <E> List<E> list(T v) {
-        return v instanceof Collection ? ((Collection<E>) v).toList() : v == null ? List.of() : List.of((E) v);
+        return v instanceof Collection ? ((Collection<E>) v).asList() : v == null ? List.of() : List.of((E) v);
     }
 
     public boolean containment() {
diff --git a/src/main/java/org/modelingvalue/dclare/IdentityDerivation.java b/src/main/java/org/modelingvalue/dclare/IdentityDerivation.java
index 32008101..728f309d 100644
--- a/src/main/java/org/modelingvalue/dclare/IdentityDerivation.java
+++ b/src/main/java/org/modelingvalue/dclare/IdentityDerivation.java
@@ -17,7 +17,7 @@
 
 public class IdentityDerivation extends ReadOnly {
 
-    protected IdentityDerivation(Object id, LeafModifier... modifiers) {
+    protected IdentityDerivation(Object id, LeafModifier<?>... modifiers) {
         super(id, modifiers);
     }
 
diff --git a/src/main/java/org/modelingvalue/dclare/IdentityDerivationTransaction.java b/src/main/java/org/modelingvalue/dclare/IdentityDerivationTransaction.java
index 7529415b..22adfcaa 100644
--- a/src/main/java/org/modelingvalue/dclare/IdentityDerivationTransaction.java
+++ b/src/main/java/org/modelingvalue/dclare/IdentityDerivationTransaction.java
@@ -40,8 +40,8 @@ public <R> R derive(Supplier<R> action, State state, int depth, Mutable contextM
     }
 
     @Override
-    protected <O, T> boolean doDerive(O object, Getable<O, T> getable) {
-        return super.doDerive(object, getable) && !isChanged(object, getable);
+    protected <O, T> boolean doDeriveGet(O object, Getable<O, T> getable, T nonDerived) {
+        return super.doDeriveGet(object, getable, nonDerived) && !isChanged(object, getable);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/org/modelingvalue/dclare/Imperative.java b/src/main/java/org/modelingvalue/dclare/Imperative.java
index b6f1aae7..bfd8bb7f 100644
--- a/src/main/java/org/modelingvalue/dclare/Imperative.java
+++ b/src/main/java/org/modelingvalue/dclare/Imperative.java
@@ -17,11 +17,11 @@
 
 public class Imperative extends Leaf {
 
-    public static Imperative of(String id, LeafModifier... modifiers) {
+    public static Imperative of(String id, LeafModifier<?>... modifiers) {
         return new Imperative(id, modifiers);
     }
 
-    protected Imperative(String id, LeafModifier... modifiers) {
+    protected Imperative(String id, LeafModifier<?>... modifiers) {
         super(id, modifiers);
     }
 
diff --git a/src/main/java/org/modelingvalue/dclare/ImperativeTransaction.java b/src/main/java/org/modelingvalue/dclare/ImperativeTransaction.java
index 48e4dc84..f730cdcf 100644
--- a/src/main/java/org/modelingvalue/dclare/ImperativeTransaction.java
+++ b/src/main/java/org/modelingvalue/dclare/ImperativeTransaction.java
@@ -45,7 +45,6 @@ public static ImperativeTransaction of(Imperative cls, State init, UniverseTrans
     private final Direction                                   direction;
     private final MutableState                                state;
 
-    private State                                             pre;
     private boolean                                           active;
     private boolean                                           commiting;
     @SuppressWarnings("rawtypes")
@@ -56,7 +55,6 @@ public static ImperativeTransaction of(Imperative cls, State init, UniverseTrans
     @SuppressWarnings("rawtypes")
     protected ImperativeTransaction(Imperative cls, State init, UniverseTransaction universeTransaction, Consumer<Runnable> scheduler, StateDeltaHandler diffHandler, boolean keepTransaction) {
         super(universeTransaction);
-        this.pre = init;
         this.state = universeTransaction.createMutableState(init);
         this.setted = SETTED_MAP;
         this.allSetted = SETTED_MAP;
@@ -104,6 +102,10 @@ public State state() {
         return state.state();
     }
 
+    public State preState() {
+        return state.preState();
+    }
+
     public MutableState mutableState() {
         return state;
     }
@@ -111,7 +113,7 @@ public MutableState mutableState() {
     public final boolean commit(State dclare, boolean timeTraveling) {
         commiting = true;
         boolean insync = setted.isEmpty() && dclare.get(this, CHANGE_NR).equals(state.get(this, CHANGE_NR));
-        if (pre != dclare) {
+        if (preState() != dclare) {
             dclare2imper(dclare, timeTraveling, insync);
         }
         if (!setted.isEmpty()) {
@@ -121,7 +123,6 @@ public final boolean commit(State dclare, boolean timeTraveling) {
             active = false;
             universeTransaction().removeActive(this);
         }
-        pre = state();
         commiting = false;
         return insync;
     }
diff --git a/src/main/java/org/modelingvalue/dclare/LazyDerivation.java b/src/main/java/org/modelingvalue/dclare/LazyDerivation.java
new file mode 100644
index 00000000..b05161a8
--- /dev/null
+++ b/src/main/java/org/modelingvalue/dclare/LazyDerivation.java
@@ -0,0 +1,39 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// (C) Copyright 2018-2023 Modeling Value Group B.V. (http://modelingvalue.org)                                        ~
+//                                                                                                                     ~
+// Licensed under the GNU Lesser General Public License v3.0 (the 'License'). You may not use this file except in      ~
+// compliance with the License. You may obtain a copy of the License at: https://choosealicense.com/licenses/lgpl-3.0  ~
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on ~
+// an 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  ~
+// specific language governing permissions and limitations under the License.                                          ~
+//                                                                                                                     ~
+// Maintainers:                                                                                                        ~
+//     Wim Bast, Tom Brus, Ronald Krijgsheld                                                                           ~
+// Contributors:                                                                                                       ~
+//     Arjan Kok, Carel Bast                                                                                           ~
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+package org.modelingvalue.dclare;
+
+public class LazyDerivation extends ReadOnly {
+
+    protected LazyDerivation(Object id, LeafModifier<?>... modifiers) {
+        super(id, modifiers);
+    }
+
+    @Override
+    public LazyDerivationTransaction openTransaction(MutableTransaction parent) {
+        return parent.universeTransaction().lazyDerivations.get().open(this, parent);
+    }
+
+    @Override
+    public void closeTransaction(Transaction tx) {
+        tx.universeTransaction().lazyDerivations.get().close((LazyDerivationTransaction) tx);
+    }
+
+    @Override
+    public LazyDerivationTransaction newTransaction(UniverseTransaction universeTransaction) {
+        return new LazyDerivationTransaction(universeTransaction);
+    }
+
+}
diff --git a/src/main/java/org/modelingvalue/dclare/LazyDerivationTransaction.java b/src/main/java/org/modelingvalue/dclare/LazyDerivationTransaction.java
new file mode 100644
index 00000000..409c818e
--- /dev/null
+++ b/src/main/java/org/modelingvalue/dclare/LazyDerivationTransaction.java
@@ -0,0 +1,112 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// (C) Copyright 2018-2023 Modeling Value Group B.V. (http://modelingvalue.org)                                        ~
+//                                                                                                                     ~
+// Licensed under the GNU Lesser General Public License v3.0 (the 'License'). You may not use this file except in      ~
+// compliance with the License. You may obtain a copy of the License at: https://choosealicense.com/licenses/lgpl-3.0  ~
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on ~
+// an 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  ~
+// specific language governing permissions and limitations under the License.                                          ~
+//                                                                                                                     ~
+// Maintainers:                                                                                                        ~
+//     Wim Bast, Tom Brus, Ronald Krijgsheld                                                                           ~
+// Contributors:                                                                                                       ~
+//     Arjan Kok, Carel Bast                                                                                           ~
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+package org.modelingvalue.dclare;
+
+import java.util.Objects;
+import java.util.concurrent.RecursiveAction;
+
+import org.modelingvalue.collections.Set;
+import org.modelingvalue.collections.util.Pair;
+
+public class LazyDerivationTransaction extends AbstractDerivationTransaction {
+
+    private static final Constant<Pair<LazyDerivationTransaction, Mutable>, RecursiveAction> LAZY_ACTION =     //
+            Constant.of("LAZY_ACTION", null, p -> new DeriveAction(p.a(), p.b()), CoreSetableModifier.durable);
+
+    private final MutableState                                                               state;
+
+    protected LazyDerivationTransaction(UniverseTransaction universeTransaction) {
+        super(universeTransaction);
+        state = new MutableState(universeTransaction.emptyState());
+    }
+
+    @Override
+    protected String getCurrentTypeForTrace() {
+        return "LZ";
+    }
+
+    public State derive() {
+        state.setState(state());
+        try {
+            deriveMutable(universeTransaction().universe());
+            return state.state();
+        } finally {
+            state.setState(universeTransaction().emptyState());
+        }
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private void doDeriveMutable(Mutable mutable) {
+        try {
+            MutableClass dClass = mutable.dClass();
+            Set<Setable> containments = MutableClass.D_CONTAINMENTS.get(dClass);
+            Set<Mutable> children = containments.flatMap(s -> s.<Mutable> getCollection(mutable)).asSet();
+            children.forEach(m -> deriveMutable((Mutable) m));
+            Set<Observer> nonDerivers = MutableClass.D_NON_DERIVERS.get(dClass).filter(d -> d.direction().isLazy()).asSet();
+            nonDerivers.forEach(o -> runDeriver(mutable, null, o, 0));
+            Set<Observed> observeds = MutableClass.D_OBSERVEDS.get(dClass);
+            observeds.forEach(o -> o.get(mutable));
+        } catch (Throwable t) {
+            universeTransaction().handleException(t);
+        }
+    }
+
+    private void deriveMutable(Mutable mutable) {
+        getAction(mutable).invoke();
+    }
+
+    private RecursiveAction getAction(Mutable mutable) {
+        return memoization().get(this, Pair.of(this, mutable), LAZY_ACTION);
+    }
+
+    @Override
+    protected <O, T> boolean doDeriveGet(O object, Getable<O, T> getable, T nonDerived) {
+        return super.doDeriveSet(object, getable) && Objects.equals(nonDerived, getable.getDefault(object)) && ifReady(object, (Setable<O, T>) getable, nonDerived);
+    }
+
+    private <O, T> boolean ifReady(O object, Setable<O, T> setable, T nonDerived) {
+        //        if (setable == Mutable.D_PARENT_CONTAINING && nonDerived == null && !memoization().isSet(this, object, setable.constant())) {
+        //            getAction((Mutable) object).join();
+        //        }
+        return true;
+    }
+
+    @Override
+    protected <T, O> void setInMemoization(ConstantState mem, O object, Setable<O, T> setable, T result) {
+        super.setInMemoization(mem, object, setable, result);
+        if (setable.preserved() && !setable.direction().isLazy()) {
+            state.set(object, setable, result);
+        }
+    }
+
+    private static final class DeriveAction extends RecursiveAction {
+        private static final long               serialVersionUID = -3996933680861103499L;
+
+        private final LazyDerivationTransaction tx;
+        private final Mutable                   mutable;
+
+        private DeriveAction(LazyDerivationTransaction tx, Mutable mutable) {
+            this.tx = tx;
+            this.mutable = mutable;
+        }
+
+        @Override
+        protected void compute() {
+            tx.doDeriveMutable(mutable);
+        }
+    }
+
+}
diff --git a/src/main/java/org/modelingvalue/dclare/Leaf.java b/src/main/java/org/modelingvalue/dclare/Leaf.java
index d5076b2c..0de4080c 100644
--- a/src/main/java/org/modelingvalue/dclare/Leaf.java
+++ b/src/main/java/org/modelingvalue/dclare/Leaf.java
@@ -15,19 +15,32 @@
 
 package org.modelingvalue.dclare;
 
+import org.modelingvalue.collections.Collection;
+import org.modelingvalue.collections.Set;
 import org.modelingvalue.collections.util.StringUtil;
 
 public abstract class Leaf implements TransactionClass, Feature {
 
-    private final Object   id;
-    private final Priority initPriority;
+    private final Object               id;
+    private final Priority             initPriority;
+    private final Set<LeafModifier<?>> modifierSet;
 
-    protected Leaf(Object id, LeafModifier... modifiers) {
+    protected Leaf(Object id, LeafModifier<?>... modifiers) {
         this.id = id;
-        Priority prio = FeatureModifier.ofClass(Priority.class, modifiers);
+        this.modifierSet = Collection.of(modifiers).notNull().asSet();
+        Priority prio = getModifier(Priority.class);
         this.initPriority = prio == null ? Priority.one : prio;
     }
 
+    public boolean hasModifier(LeafModifier<?> modifier) {
+        return modifierSet.contains(modifier);
+    }
+
+    @SuppressWarnings({"unused", "unchecked"})
+    public <SM extends LeafModifier<?>> SM getModifier(Class<SM> modifierClass) {
+        return (SM) FeatureModifier.ofClass(modifierClass, modifierSet);
+    }
+
     @Override
     public int hashCode() {
         return id.hashCode() ^ getClass().hashCode();
diff --git a/src/main/java/org/modelingvalue/dclare/LeafModifier.java b/src/main/java/org/modelingvalue/dclare/LeafModifier.java
index ce9bd5c2..6c3aa05b 100644
--- a/src/main/java/org/modelingvalue/dclare/LeafModifier.java
+++ b/src/main/java/org/modelingvalue/dclare/LeafModifier.java
@@ -15,34 +15,34 @@
 
 package org.modelingvalue.dclare;
 
-public interface LeafModifier extends FeatureModifier<LeafModifier> {
+public interface LeafModifier<M extends LeafModifier<?>> extends FeatureModifier<M> {
 
-    static LeafModifier anonymous = new LeafModifier() {
-                                      @Override
-                                      public String toString() {
-                                          return "anonymous";
-                                      }
-                                  };
+    static LeafModifier<LeafModifier<?>> anonymous = new LeafModifier<>() {
+                                                       @Override
+                                                       public String toString() {
+                                                           return "anonymous";
+                                                       }
+                                                   };
 
-    static LeafModifier preserved = new LeafModifier() {
-                                      @Override
-                                      public String toString() {
-                                          return "preserved";
-                                      }
-                                  };
+    static LeafModifier<LeafModifier<?>> preserved = new LeafModifier<>() {
+                                                       @Override
+                                                       public String toString() {
+                                                           return "preserved";
+                                                       }
+                                                   };
 
-    static LeafModifier atomic    = new LeafModifier() {
-                                      @Override
-                                      public String toString() {
-                                          return "atomic";
-                                      }
-                                  };
+    static LeafModifier<LeafModifier<?>> atomic    = new LeafModifier<>() {
+                                                       @Override
+                                                       public String toString() {
+                                                           return "atomic";
+                                                       }
+                                                   };
 
-    static LeafModifier read      = new LeafModifier() {
-                                      @Override
-                                      public String toString() {
-                                          return "read";
-                                      }
-                                  };
+    static LeafModifier<LeafModifier<?>> read      = new LeafModifier<>() {
+                                                       @Override
+                                                       public String toString() {
+                                                           return "read";
+                                                       }
+                                                   };
 
 }
diff --git a/src/main/java/org/modelingvalue/dclare/LeafTransaction.java b/src/main/java/org/modelingvalue/dclare/LeafTransaction.java
index c3fcf5cc..adc6ed1d 100644
--- a/src/main/java/org/modelingvalue/dclare/LeafTransaction.java
+++ b/src/main/java/org/modelingvalue/dclare/LeafTransaction.java
@@ -187,7 +187,7 @@ public <O extends Mutable> O construct(Construction.Reason reason, Supplier<O> s
             result = constantState().get(this, reason, Construction.CONSTRUCTED);
         }
         if (result != null) {
-            constantState().set(this, result, Newable.D_INITIAL_CONSTRUCTION, Construction.of(reason), true);
+            constantState().set(this, result, Mutable.D_INITIAL_CONSTRUCTION, Construction.of(reason), true);
         }
         return (O) result;
     }
diff --git a/src/main/java/org/modelingvalue/dclare/MatchInfo.java b/src/main/java/org/modelingvalue/dclare/MatchInfo.java
index 9f9a6da1..842e9e8e 100644
--- a/src/main/java/org/modelingvalue/dclare/MatchInfo.java
+++ b/src/main/java/org/modelingvalue/dclare/MatchInfo.java
@@ -111,7 +111,7 @@ public String toString() {
     }
 
     private Set<Direction> directions() {
-        Set<Direction> result = allDerivations.map(Construction::reason).map(Reason::direction).toSet();
+        Set<Direction> result = allDerivations.map(Construction::reason).map(Reason::direction).asSet();
         result = result.add(initialConstruction.reason().direction());
         return result;
     }
diff --git a/src/main/java/org/modelingvalue/dclare/Mutable.java b/src/main/java/org/modelingvalue/dclare/Mutable.java
index 19201c94..4e1377c2 100644
--- a/src/main/java/org/modelingvalue/dclare/Mutable.java
+++ b/src/main/java/org/modelingvalue/dclare/Mutable.java
@@ -15,7 +15,7 @@
 
 package org.modelingvalue.dclare;
 
-import static org.modelingvalue.dclare.SetableModifier.*;
+import static org.modelingvalue.dclare.CoreSetableModifier.*;
 
 import java.util.function.Predicate;
 
@@ -46,7 +46,7 @@ public interface Mutable extends TransactionClass {
             removed -> {
             }));
 
-    Observer<Mutable>                                        D_OBSERVERS_RULE         = NonCheckingObserver.of("D_OBSERVERS_RULE", m -> D_OBSERVERS.set(m, m.dAllObservers().toSet()));
+    Observer<Mutable>                                        D_OBSERVERS_RULE         = NonCheckingObserver.of("D_OBSERVERS_RULE", m -> D_OBSERVERS.set(m, m.dAllObservers().exclude(o -> o.direction().isLazy()).asSet()));
 
     @SuppressWarnings("unchecked")
     Observer<Mutable>                                        D_PUSHING_CONSTANTS_RULE = NonCheckingObserver.of("D_PUSHING_CONSTANTS_RULE", m -> MutableClass.D_PUSHING_CONSTANTS.get(m.dClass()).forEachOrdered(c -> c.get(m)));
@@ -242,9 +242,8 @@ default ConstantState dMemoization(AbstractDerivationTransaction tx) {
         return tx.memoization();
     }
 
-    static final class ParentContaining extends Observed<Mutable, Pair<Mutable, Setable<Mutable, ?>>> {
-
-        private ParentContaining(Object id, SetableModifier... modifiers) {
+    final class ParentContaining extends Observed<Mutable, Pair<Mutable, Setable<Mutable, ?>>> {
+        private ParentContaining(Object id, SetableModifier<?>... modifiers) {
             super(id, null, null, null, (tx, m, b, a) -> m.dChangedParentContaining(b, a), modifiers);
         }
 
@@ -256,7 +255,5 @@ private ParentContaining(Object id, SetableModifier... modifiers) {
         private Pair<Mutable, Setable<Mutable, ?>> superGet(Mutable object) {
             return super.get(object);
         }
-
     }
-
 }
diff --git a/src/main/java/org/modelingvalue/dclare/MutableClass.java b/src/main/java/org/modelingvalue/dclare/MutableClass.java
index 56717d5b..3a2e93d7 100644
--- a/src/main/java/org/modelingvalue/dclare/MutableClass.java
+++ b/src/main/java/org/modelingvalue/dclare/MutableClass.java
@@ -25,23 +25,27 @@ public interface MutableClass extends Internable {
 
     @SuppressWarnings({"rawtypes"})
     Constant<MutableClass, Set<Setable>>                       D_CONTAINMENTS      = Constant.of("D_CONTAINMENTS",                                                                         //
-            c -> c.dSetables().filter(Setable::containment).map(s -> (Setable) s).toSet());
+            c -> c.dSetables().filter(Setable::containment).map(s -> (Setable) s).asSet());
 
     @SuppressWarnings({"rawtypes"})
     Constant<MutableClass, Set<Observed>>                      D_OBSERVEDS         = Constant.of("D_OBSERVEDS",                                                                            //
-            c -> c.dSetables().filter(s -> s instanceof Observed).map(s -> (Observed) s).toSet());
+            c -> c.dSetables().filter(s -> s instanceof Observed).map(s -> (Observed) s).asSet());
 
     @SuppressWarnings({"rawtypes"})
     Constant<MutableClass, Set<Constant>>                      D_PUSHING_CONSTANTS = Constant.of("D_PUSHING_CONSTANTS",                                                                    //
-            c -> c.dSetables().filter(s -> s instanceof Constant && s.isHandlingChange() && ((Constant) s).deriver() != null).map(s -> (Constant) s).toSet());
+            c -> c.dSetables().filter(s -> s instanceof Constant && s.isHandlingChange() && ((Constant) s).deriver() != null).map(s -> (Constant) s).asSet());
 
     @SuppressWarnings({"rawtypes", "unchecked"})
     Constant<MutableClass, DefaultMap<Setable, Set<Observer>>> D_DERIVERS          = Constant.of("D_DERIVERS",                                                                             //
             c -> {
-                Set<Setable> setables = (Set) c.dObservers().flatMap(Observer::targets).toSet();
-                return setables.toDefaultMap(k -> Set.of(), s -> Entry.<Setable, Set<Observer>> of(s, c.dObservers().map(o -> (Observer) o).filter(o -> o.targets().contains(s)).toSet()));
+                Set<Setable> setables = (Set) c.dObservers().flatMap(Observer::targets).asSet();
+                return setables.asDefaultMap(k -> Set.of(), s -> Entry.<Setable, Set<Observer>> of(s, c.dObservers().map(o -> (Observer) o).filter(o -> o.targets().contains(s)).asSet()));
             });
 
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    Constant<MutableClass, Set<Observer>>                      D_NON_DERIVERS      = Constant.of("D_NON_DERIVERS",                                                                         //
+            c -> c.dObservers().filter(o -> o.targets().isEmpty()).map(s -> (Observer) s).asSet());
+
     Collection<? extends Observer<?>> dObservers();
 
     Collection<? extends Setable<? extends Mutable, ?>> dSetables();
diff --git a/src/main/java/org/modelingvalue/dclare/MutableTransaction.java b/src/main/java/org/modelingvalue/dclare/MutableTransaction.java
index b69afbcf..4614a1ef 100644
--- a/src/main/java/org/modelingvalue/dclare/MutableTransaction.java
+++ b/src/main/java/org/modelingvalue/dclare/MutableTransaction.java
@@ -125,7 +125,7 @@ protected State run(State pre) {
     }
 
     private void run(Set<Action<?>> actions, Set<Mutable> children) {
-        List<? extends TransactionClass> random = Collection.concat(actions, children).random().toList();
+        List<? extends TransactionClass> random = Collection.concat(actions, children).random().asList();
         if (universeTransaction().getConfig().isTraceMutable()) {
             System.err.println(DclareTrace.getLineStart("DCLARE", this) + mutable() + " " + random.toString().substring(4));
         }
@@ -237,7 +237,7 @@ public void handleChange(Object object, Setable setable, DefaultMap<Setable, Obj
                     if (!Objects.equals(branchValue, baseValue)) {
                         DefaultMap<Observer, Set<Mutable>> branchObservers = StateMap.get(branchValues, os);
                         Map<Observer, Set<Mutable>> missingBranchObservers = addedResultObservers.removeAll(branchObservers, Set::removeAll).//
-                                toMap(e -> Entry.of(e.getKey(), e.getValue().map(m -> m.dResolve((Mutable) object)).toSet()));
+                                asMap(e -> Entry.of(e.getKey(), e.getValue().map(m -> m.dResolve((Mutable) object)).asSet()));
                         triggeredActions.change(ts -> ts.addAll(missingBranchObservers, Set::addAll));
                     }
                 }
diff --git a/src/main/java/org/modelingvalue/dclare/Newable.java b/src/main/java/org/modelingvalue/dclare/Newable.java
index ad48f878..44cbd476 100644
--- a/src/main/java/org/modelingvalue/dclare/Newable.java
+++ b/src/main/java/org/modelingvalue/dclare/Newable.java
@@ -15,15 +15,14 @@
 
 package org.modelingvalue.dclare;
 
-import static org.modelingvalue.dclare.SetableModifier.durable;
-import static org.modelingvalue.dclare.SetableModifier.plumbing;
+import static org.modelingvalue.dclare.CoreSetableModifier.durable;
+import static org.modelingvalue.dclare.CoreSetableModifier.plumbing;
 
 public interface Newable extends Mutable {
 
     Constant<Newable, Object> D_IDENTITY  = Constant.of("D_IDENTITY", null, plumbing, durable);
     Setable<Newable, Newable> D_REPLACING = Setable.of("D_REPLACING", null, plumbing);
 
-    @SuppressWarnings("rawtypes")
     Object dIdentity();
 
     Object dNewableType();
diff --git a/src/main/java/org/modelingvalue/dclare/NonCheckingObserver.java b/src/main/java/org/modelingvalue/dclare/NonCheckingObserver.java
index 290ae793..1df38b01 100644
--- a/src/main/java/org/modelingvalue/dclare/NonCheckingObserver.java
+++ b/src/main/java/org/modelingvalue/dclare/NonCheckingObserver.java
@@ -23,20 +23,20 @@
 
 public class NonCheckingObserver<O extends Mutable> extends Observer<O> {
 
-    public static <M extends Mutable> NonCheckingObserver<M> of(Object id, Consumer<M> action, LeafModifier... modifiers) {
+    public static <M extends Mutable> NonCheckingObserver<M> of(Object id, Consumer<M> action, LeafModifier<?>... modifiers) {
         return new NonCheckingObserver<>(id, action, modifiers);
     }
 
-    public static <M extends Mutable, V> NonCheckingObserver<M> of(Setable<M, V> setable, Function<M, V> value, LeafModifier... modifiers) {
+    public static <M extends Mutable, V> NonCheckingObserver<M> of(Setable<M, V> setable, Function<M, V> value, LeafModifier<?>... modifiers) {
         return new NonCheckingObserver<>(setable, value, modifiers);
     }
 
-    protected NonCheckingObserver(Object id, Consumer<O> action, LeafModifier... modifiers) {
+    protected NonCheckingObserver(Object id, Consumer<O> action, LeafModifier<?>... modifiers) {
         super(id, action, Set.of(), modifiers);
     }
 
     @SuppressWarnings({"unchecked", "rawtypes"})
-    protected <T> NonCheckingObserver(Setable<O, T> setable, Function<O, T> value, LeafModifier... modifiers) {
+    protected <T> NonCheckingObserver(Setable<O, T> setable, Function<O, T> value, LeafModifier<?>... modifiers) {
         super(setable, setable, value, modifiers);
     }
 
diff --git a/src/main/java/org/modelingvalue/dclare/NonInternableObserver.java b/src/main/java/org/modelingvalue/dclare/NonInternableObserver.java
index 18aa1a95..a367c101 100644
--- a/src/main/java/org/modelingvalue/dclare/NonInternableObserver.java
+++ b/src/main/java/org/modelingvalue/dclare/NonInternableObserver.java
@@ -20,11 +20,11 @@
 @SuppressWarnings("unused")
 public class NonInternableObserver<O extends Mutable> extends Observer<O> {
 
-    public static <M extends Mutable> NonInternableObserver<M> of(Object id, Consumer<M> action, LeafModifier... modifiers) {
+    public static <M extends Mutable> NonInternableObserver<M> of(Object id, Consumer<M> action, LeafModifier<?>... modifiers) {
         return new NonInternableObserver<>(id, action, modifiers);
     }
 
-    protected NonInternableObserver(Object id, Consumer<O> action, LeafModifier... modifiers) {
+    protected NonInternableObserver(Object id, Consumer<O> action, LeafModifier<?>... modifiers) {
         super(id, action, modifiers);
     }
 
diff --git a/src/main/java/org/modelingvalue/dclare/Observed.java b/src/main/java/org/modelingvalue/dclare/Observed.java
index 110851fe..0143e817 100644
--- a/src/main/java/org/modelingvalue/dclare/Observed.java
+++ b/src/main/java/org/modelingvalue/dclare/Observed.java
@@ -32,43 +32,43 @@ public class Observed<O, T> extends Setable<O, T> {
     @SuppressWarnings("rawtypes")
     protected static final DefaultMap<Observed, Set<Mutable>> OBSERVED_MAP = DefaultMap.of(k -> Set.of());
 
-    public static <C, V> Observed<C, V> of(Object id, V def, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, V def, SetableModifier<?>... modifiers) {
         return new Observed<>(id, c -> def, null, null, null, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier<?>... modifiers) {
         return new Observed<>(id, c -> def, null, null, changed, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, SetableModifier<?>... modifiers) {
         return new Observed<>(id, c -> def, opposite, null, null, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, Supplier<Setable<C, Set<?>>> scope, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, Supplier<Setable<C, Set<?>>> scope, SetableModifier<?>... modifiers) {
         return new Observed<>(id, c -> def, null, scope, changed, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, SetableModifier<?>... modifiers) {
         return new Observed<>(id, c -> def, opposite, scope, null, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, SetableModifier<?>... modifiers) {
         return new Observed<>(id, def, null, null, null, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier<?>... modifiers) {
         return new Observed<>(id, def, null, null, changed, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, Supplier<Setable<?, ?>> opposite, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, Supplier<Setable<?, ?>> opposite, SetableModifier<?>... modifiers) {
         return new Observed<>(id, def, opposite, null, null, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, QuadConsumer<LeafTransaction, C, V, V> changed, Supplier<Setable<C, Set<?>>> scope, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, QuadConsumer<LeafTransaction, C, V, V> changed, Supplier<Setable<C, Set<?>>> scope, SetableModifier<?>... modifiers) {
         return new Observed<>(id, def, null, scope, changed, modifiers);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, SetableModifier<?>... modifiers) {
         return new Observed<>(id, def, opposite, scope, null, modifiers);
     }
 
@@ -80,9 +80,9 @@ public static <C, V> Observed<C, V> of(Object id, Function<C, V> def, Supplier<S
     private final Entry<Observed, Set<Mutable>>       thisInstance = Entry.of(this, Mutable.THIS_SINGLETON);
 
     @SuppressWarnings({"unchecked", "rawtypes"})
-    protected Observed(Object id, Function<O, T> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<O, Set<?>>> scope, QuadConsumer<LeafTransaction, O, T, T> changed, SetableModifier... modifiers) {
+    protected Observed(Object id, Function<O, T> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<O, Set<?>>> scope, QuadConsumer<LeafTransaction, O, T, T> changed, SetableModifier<?>... modifiers) {
         super(id, def, opposite, scope, changed, modifiers);
-        this.mandatory = SetableModifier.mandatory.in(modifiers);
+        this.mandatory = hasModifier(CoreSetableModifier.mandatory);
         this.observers = new Observers<>(this);
     }
 
@@ -125,9 +125,9 @@ public static final class Observers<O, T> extends Setable<O, DefaultMap<Observer
 
         @SuppressWarnings("unchecked")
         private Observers(Observed observed) {
-            super(observed, o -> Observer.OBSERVER_MAP, null, null, (tx, o, b, a) -> {
-                observed.checkTooManyObservers(tx.universeTransaction(), o, a);
-            }, SetableModifier.plumbing);
+            super(observed, o -> Observer.OBSERVER_MAP, null, null, //
+                    (tx, o, b, a) -> observed.checkTooManyObservers(tx.universeTransaction(), o, a), //
+                    CoreSetableModifier.plumbing);
         }
 
         @SuppressWarnings("unchecked")
@@ -148,7 +148,7 @@ protected Entry<Observed, Set<Mutable>> entry(Mutable object, Mutable self) {
 
     @Override
     public boolean checkConsistency() {
-        return !isPlumbing() && (mandatory || super.checkConsistency());
+        return !isPlumbing() && !direction().isLazy() && (mandatory || super.checkConsistency());
     }
 
     @Override
diff --git a/src/main/java/org/modelingvalue/dclare/Observer.java b/src/main/java/org/modelingvalue/dclare/Observer.java
index d5b9a2ce..377d0ca1 100644
--- a/src/main/java/org/modelingvalue/dclare/Observer.java
+++ b/src/main/java/org/modelingvalue/dclare/Observer.java
@@ -43,25 +43,25 @@ public class Observer<O extends Mutable> extends Action<O> implements Internable
     @SuppressWarnings("rawtypes")
     protected static final DefaultMap<Observer, Set<Mutable>> OBSERVER_MAP = DefaultMap.of(k -> Set.of());
 
-    public static <M extends Mutable> Observer<M> of(Object id, Consumer<M> action, Set<Setable<M, ?>> targets, LeafModifier... modifiers) {
+    public static <M extends Mutable> Observer<M> of(Object id, Consumer<M> action, Set<Setable<M, ?>> targets, LeafModifier<?>... modifiers) {
         return new Observer<M>(id, action, targets, modifiers);
     }
 
-    public static <M extends Mutable> Observer<M> of(Object id, Consumer<M> action, LeafModifier... modifiers) {
+    public static <M extends Mutable> Observer<M> of(Object id, Consumer<M> action, LeafModifier<?>... modifiers) {
         return new Observer<M>(id, action, modifiers);
     }
 
-    public static <M extends Mutable> Observer<M> of(Object id, Predicate<M> predicate, Consumer<M> action, LeafModifier... modifiers) {
+    public static <M extends Mutable> Observer<M> of(Object id, Predicate<M> predicate, Consumer<M> action, LeafModifier<?>... modifiers) {
         return new Observer<M>(id, predicate, action, modifiers);
     }
 
     @SuppressWarnings("unchecked")
-    public static <M extends Mutable, V> Observer<M> of(Object id, Setable<M, V> setable, Function<M, V> value, LeafModifier... modifiers) {
+    public static <M extends Mutable, V> Observer<M> of(Object id, Setable<M, V> setable, Function<M, V> value, LeafModifier<?>... modifiers) {
         return new Observer<M>(id, setable, value, modifiers);
     }
 
     @SuppressWarnings("unchecked")
-    public static <M extends Mutable, V> Observer<M> of(Object id, Setable<M, V> setable, Predicate<M> predicate, Function<M, V> value, LeafModifier... modifiers) {
+    public static <M extends Mutable, V> Observer<M> of(Object id, Setable<M, V> setable, Predicate<M> predicate, Function<M, V> value, LeafModifier<?>... modifiers) {
         return new Observer<M>(id, setable, predicate, value, modifiers);
     }
 
@@ -84,11 +84,11 @@ public static <M extends Mutable, V> Observer<M> of(Object id, Setable<M, V> set
     @SuppressWarnings("rawtypes")
     private final Entry<Observer, Set<Mutable>> thisInstance = Entry.of(this, Mutable.THIS_SINGLETON);
 
-    protected Observer(Object id, Consumer<O> action, LeafModifier... modifiers) {
+    protected Observer(Object id, Consumer<O> action, LeafModifier<?>... modifiers) {
         this(id, action, Set.of(), modifiers);
     }
 
-    protected Observer(Object id, Predicate<O> predicate, Consumer<O> action, LeafModifier... modifiers) {
+    protected Observer(Object id, Predicate<O> predicate, Consumer<O> action, LeafModifier<?>... modifiers) {
         this(id, o -> {
             if (predicate.test(o)) {
                 action.accept(o);
@@ -97,12 +97,12 @@ protected Observer(Object id, Predicate<O> predicate, Consumer<O> action, LeafMo
     }
 
     @SuppressWarnings({"unchecked", "rawtypes"})
-    protected <T> Observer(Object id, Setable<O, T> setable, Function<O, T> value, LeafModifier... modifiers) {
+    protected <T> Observer(Object id, Setable<O, T> setable, Function<O, T> value, LeafModifier<?>... modifiers) {
         this(id, o -> setable.set(o, value.apply(o)), Set.of(setable), modifiers);
     }
 
     @SuppressWarnings({"unchecked", "rawtypes"})
-    protected <T> Observer(Object id, Setable<O, T> setable, Predicate<O> predicate, Function<O, T> value, LeafModifier... modifiers) {
+    protected <T> Observer(Object id, Setable<O, T> setable, Predicate<O> predicate, Function<O, T> value, LeafModifier<?>... modifiers) {
         this(id, o -> {
             if (predicate.test(o)) {
                 setable.set(o, value.apply(o));
@@ -111,7 +111,7 @@ protected <T> Observer(Object id, Setable<O, T> setable, Predicate<O> predicate,
     }
 
     @SuppressWarnings("rawtypes")
-    protected Observer(Object id, Consumer<O> action, Set<Setable<O, ?>> targets, LeafModifier... modifiers) {
+    protected Observer(Object id, Consumer<O> action, Set<Setable<O, ?>> targets, LeafModifier<?>... modifiers) {
         super(id, action, modifiers);
         traces = new Traces(Pair.of(this, "TRACES"));
         debugs = new Debugs(Pair.of(this, "DEBUGS"));
@@ -119,8 +119,8 @@ protected Observer(Object id, Consumer<O> action, Set<Setable<O, ?>> targets, Le
         exception = ExceptionSetable.of(this);
         constructed = Constructed.of(this);
         this.targets = targets;
-        this.anonymous = LeafModifier.anonymous.in(modifiers);
-        this.atomic = LeafModifier.atomic.in(modifiers);
+        this.anonymous = hasModifier(LeafModifier.anonymous);
+        this.atomic = hasModifier(LeafModifier.atomic);
     }
 
     public Observerds observeds() {
@@ -209,8 +209,7 @@ protected final void stop() {
 
     @SuppressWarnings("rawtypes")
     public static final class Traces extends Setable<Mutable, List<ObserverTrace>> {
-
-        protected Traces(Pair<Observer, String> id) {
+        private Traces(Pair<Observer, String> id) {
             super(id, m -> List.of(), null, null, null);
         }
 
@@ -248,8 +247,7 @@ private Observer observer() {
 
     @SuppressWarnings("rawtypes")
     public static final class Debugs extends Setable<Mutable, List<ObserverTrace>> {
-
-        protected Debugs(Pair<Observer, String> id) {
+        private Debugs(Pair<Observer, String> id) {
             super(id, m -> List.of(), null, null, null);
         }
 
@@ -287,7 +285,7 @@ Setable.<Set<Mutable>, Mutable> diff(pre.get(observed), post.get(observed), a ->
                         tx.set(o, obs, (m, e) -> m.remove(e, Set::removeAll), observer.entry(mutable, o));
                     });
                 }
-            }, SetableModifier.plumbing);
+            }, CoreSetableModifier.plumbing);
         }
 
         public Observer observer() {
@@ -311,7 +309,7 @@ public static ExceptionSetable of(Observer observer) {
         private final Observer observer;
 
         private ExceptionSetable(Observer observer) {
-            super(Pair.of(observer, "exception"), null, null, null, null, SetableModifier.plumbing);
+            super(Pair.of(observer, "exception"), null, null, null, null, CoreSetableModifier.plumbing);
             this.observer = observer;
         }
 
@@ -369,7 +367,7 @@ private Constructed(Observer observer) {
                         }
                     }
                 }
-            }, SetableModifier.plumbing, SetableModifier.doNotMerge);
+            }, CoreSetableModifier.plumbing, CoreSetableModifier.doNotMerge);
         }
 
         @Override
diff --git a/src/main/java/org/modelingvalue/dclare/ObserverTrace.java b/src/main/java/org/modelingvalue/dclare/ObserverTrace.java
index 79cefd1c..cd74335e 100644
--- a/src/main/java/org/modelingvalue/dclare/ObserverTrace.java
+++ b/src/main/java/org/modelingvalue/dclare/ObserverTrace.java
@@ -51,16 +51,16 @@ protected ObserverTrace(Mutable mutable, Observer<?> observer, ObserverTrace pre
             e.getKey().observed().writers().set(e.getKey().mutable(), Set::add, this);
         }
         Set<ObserverTrace> done = previous != null ? previous.done : Set.of();
-        Map<ObservedInstance, Set<ObserverTrace>> backTrace = read.toMap(e -> {
+        Map<ObservedInstance, Set<ObserverTrace>> backTrace = read.asMap(e -> {
             ObservedInstance observedInstance = e.getKey();
             Set<ObserverTrace> writers = observedInstance.observed().writers().get(observedInstance.mutable());
             return Entry.of(observedInstance, writers.removeAll(done).remove(this));
         });
-        Set<ObserverTrace> back = backTrace.flatMap(Entry::getValue).toSet();
-        Set<ObserverTrace> backDone = back.flatMap(ObserverTrace::done).toSet();
-        backTrace = backTrace.toMap(e -> Entry.of(e.getKey(), e.getValue().removeAll(backDone)));
+        Set<ObserverTrace> back = backTrace.flatMap(Entry::getValue).asSet();
+        Set<ObserverTrace> backDone = back.flatMap(ObserverTrace::done).asSet();
+        backTrace = backTrace.asMap(e -> Entry.of(e.getKey(), e.getValue().removeAll(backDone)));
         if (backTrace.anyMatch(e -> e.getValue().anyMatch(w -> !w.mutable.equals(mutable) || !w.observer.equals(observer)))) {
-            backTrace = backTrace.toMap(e -> Entry.of(e.getKey(), e.getValue().filter(w -> !w.mutable.equals(mutable) || !w.observer.equals(observer)).toSet()));
+            backTrace = backTrace.asMap(e -> Entry.of(e.getKey(), e.getValue().filter(w -> !w.mutable.equals(mutable) || !w.observer.equals(observer)).asSet()));
         }
         this.backTrace = backTrace;
         this.done = done.addAll(back).addAll(backDone).addAll(previous != null ? previous.done.add(previous) : Set.of());
@@ -129,13 +129,17 @@ private <C> void trace(C context, BiConsumer<C, ObserverTrace> runHandler, TriCo
         runHandler.accept(context, this);
         if (done[0].size() < length && !done[0].contains(this)) {
             done[0] = done[0].add(this);
-            for (Entry<ObservedInstance, Set<ObserverTrace>> e : backTrace()) {
-                if (!e.getValue().isEmpty()) {
-                    readHandler.accept(context, this, e.getKey());
-                    for (ObserverTrace writer : e.getValue()) {
-                        writeHandler.accept(context, writer, e.getKey());
-                        writer.trace(traceHandler.apply(context), runHandler, readHandler, writeHandler, traceHandler, done, length);
-                    }
+            traceBack(traceHandler.apply(context), runHandler, readHandler, writeHandler, traceHandler, done, length);
+        }
+    }
+
+    private <C> void traceBack(C context, BiConsumer<C, ObserverTrace> runHandler, TriConsumer<C, ObserverTrace, ObservedInstance> readHandler, TriConsumer<C, ObserverTrace, ObservedInstance> writeHandler, Function<C, C> traceHandler, Set<ObserverTrace>[] done, int length) {
+        for (Entry<ObservedInstance, Set<ObserverTrace>> e : backTrace()) {
+            if (!e.getValue().isEmpty()) {
+                writeHandler.accept(context, this, e.getKey());
+                readHandler.accept(context, this, e.getKey());
+                for (ObserverTrace writer : e.getValue()) {
+                    writer.trace(traceHandler.apply(context), runHandler, readHandler, writeHandler, traceHandler, done, length);
                 }
             }
         }
diff --git a/src/main/java/org/modelingvalue/dclare/ObserverTransaction.java b/src/main/java/org/modelingvalue/dclare/ObserverTransaction.java
index 124cfb88..00219d54 100644
--- a/src/main/java/org/modelingvalue/dclare/ObserverTransaction.java
+++ b/src/main/java/org/modelingvalue/dclare/ObserverTransaction.java
@@ -48,7 +48,6 @@ public class ObserverTransaction extends ActionTransaction {
 
     private Pair<Instant, Throwable>                             throwable;
 
-    @SuppressWarnings("unchecked")
     protected ObserverTransaction(UniverseTransaction universeTransaction) {
         super(universeTransaction);
     }
@@ -68,7 +67,7 @@ protected State merge() {
         emptyMandatory.merge();
         changed.merge();
         defer.merge();
-        Map<Reason, Mutable> cons = constructions.merge();
+        Map<Reason, Mutable> cons = constructions.merge(); //TODO @WIM: why is this not done in the 'if' below?
         if (throwable == null) {
             Set<Boolean> ch = changed.get();
             observer().constructed().set(mutable(), cons);
@@ -102,21 +101,18 @@ protected final void run(State pre, UniverseTransaction universeTransaction) {
             try {
                 doRun(pre, universeTransaction);
             } catch (Throwable t) {
-                do {
-                    if (t instanceof ConsistencyError) {
+                for (Throwable tt = t; tt != null; tt = tt.getCause()) {
+                    if (tt instanceof ConsistencyError) {
                         observer().stop();
-                        throwable = Pair.of(Instant.now(), t);
-                        return;
-                    } else if (t instanceof NullPointerException) {
-                        throwable = Pair.of(Instant.now(), t);
+                        throwable = Pair.of(Instant.now(), tt);
                         return;
-                    } else if (t.getCause() != null) {
-                        t = t.getCause();
-                    } else {
-                        throwable = Pair.of(Instant.now(), t);
+                    }
+                    if (tt instanceof NullPointerException) {
+                        throwable = Pair.of(Instant.now(), tt);
                         return;
                     }
-                } while (true);
+                }
+                throwable = Pair.of(Instant.now(), t);
             } finally {
                 merge();
                 finish(pre, observer);
@@ -184,7 +180,7 @@ protected void checkTooManyObserved(Mutable mutable, DefaultMap<Observed, Set<Mu
         }
     }
 
-    @SuppressWarnings({"unchecked", "rawtypes"})
+    @SuppressWarnings({"rawtypes"})
     protected int checkTooManyChanges(State pre, DefaultMap<Observed, Set<Mutable>> observeds) {
         UniverseStatistics stats = universeTransaction().stats();
         int totalChanges = stats.bumpAndGetTotalChanges();
@@ -205,7 +201,7 @@ protected void bumpTotalChanges() {
         // Do nothing, already done by checkTooManyChanges
     }
 
-    @SuppressWarnings({"rawtypes", "unchecked"})
+    @SuppressWarnings({"rawtypes"})
     protected void trace(State pre, DefaultMap<Observed, Set<Mutable>> observeds, int changes) {
         if (observer().isTracing()) {
             trace(pre, observeds, changes, observer().traces());
@@ -226,10 +222,8 @@ private ObserverTrace trace(State pre, DefaultMap<Observed, Set<Mutable>> observ
                 observeds.filter(e -> !e.getKey().isPlumbing()).flatMap(e -> e.getValue().map(m -> {
                     m = m.dResolve(mutable());
                     return Entry.of(ObservedInstance.of(m, e.getKey()), pre.get(m, e.getKey()));
-                })).toMap(e -> e), //
-                pre.diff(current(), o -> o instanceof Mutable, s -> s instanceof Observed && !s.isPlumbing()).flatMap(e1 -> {
-                    return e1.getValue().map(e2 -> Entry.of(ObservedInstance.of((Mutable) e1.getKey(), (Observed) e2.getKey()), e2.getValue().b()));
-                }).toMap(e -> e));
+                })).asMap(e -> e), //
+                pre.diff(current(), o -> o instanceof Mutable, s -> s instanceof Observed && !s.isPlumbing()).flatMap(e1 -> e1.getValue().map(e2 -> Entry.of(ObservedInstance.of((Mutable) e1.getKey(), (Observed) e2.getKey()), e2.getValue().b()))).asMap(e -> e));
         setable.set(mutable(), traces.append(trace));
         return trace;
     }
@@ -245,20 +239,19 @@ public <O, T> T get(O object, Getable<O, T> getable) {
             observe(object, (Observed<O, T>) getable);
         }
         T result = super.get(object, getable);
-        if (result == null && getable instanceof Observed && ((Observed) getable).mandatory()) {
+        if (result == null && getable instanceof Observed && getable.mandatory()) {
             emptyMandatory.set(TRUE);
         }
         return result;
     }
 
-    @SuppressWarnings("rawtypes")
     @Override
     public <O, T> T pre(O object, Getable<O, T> getable) {
         if (observing(object, getable)) {
             observe(object, (Observed<O, T>) getable);
         }
         T result = super.pre(object, getable);
-        if (result == null && getable instanceof Observed && ((Observed) getable).mandatory()) {
+        if (result == null && getable instanceof Observed && getable.mandatory()) {
             result = super.get(object, getable);
             if (result == null) {
                 emptyMandatory.set(TRUE);
@@ -267,14 +260,13 @@ public <O, T> T pre(O object, Getable<O, T> getable) {
         return result;
     }
 
-    @SuppressWarnings("rawtypes")
     @Override
     public <O, T> T current(O object, Getable<O, T> getable) {
         if (observing(object, getable)) {
             observe(object, (Observed<O, T>) getable);
         }
         T result = super.current(object, getable);
-        if (result == null && getable instanceof Observed && ((Observed) getable).mandatory()) {
+        if (result == null && getable instanceof Observed && getable.mandatory()) {
             emptyMandatory.set(TRUE);
         }
         return result;
@@ -285,7 +277,7 @@ public <O, T> T current(O object, Getable<O, T> getable) {
     protected <T, O> void set(O object, Setable<O, T> setable, T pre, T post) {
         T result = post;
         if (observing(object, setable)) {
-            if (((Observed) setable).mandatory() && !setable.isPlumbing() && !Objects.equals(pre, post) && ((Observed) setable).isEmpty(post) && emptyMandatory.merge().equals(TRUE)) {
+            if (setable.mandatory() && !setable.isPlumbing() && !Objects.equals(pre, post) && setable.isEmpty(post) && emptyMandatory.merge().equals(TRUE)) {
                 throw new NullPointerException(setable.toString());
             }
             observe(object, (Observed<O, T>) setable);
@@ -305,7 +297,6 @@ protected <T, O> void set(O object, Setable<O, T> setable, T pre, T post) {
         super.set(object, setable, pre, result);
     }
 
-    @SuppressWarnings("rawtypes")
     private static <T> boolean isCollection(T val) {
         return val == null || val instanceof ContainingCollection;
     }
@@ -405,7 +396,7 @@ private void setConstructed(Construction.Reason reason, Construction cons, Mutab
     }
 
     private Map<Reason, Mutable> actualize(Map<Reason, Mutable> map) {
-        return map.flatMap(e -> e.getKey().actualize().map(r -> Entry.of(r, e.getValue()))).toMap(Function.identity());
+        return map.flatMap(e -> e.getKey().actualize().map(r -> Entry.of(r, e.getValue()))).asMap(Function.identity());
     }
 
     @SuppressWarnings("unchecked")
@@ -487,11 +478,7 @@ private <O, T, E> boolean isForward(O outObject, Observed<O, T> outObserved, T p
 
     private <O, T, E> boolean isChanged(O object, Observed<O, T> many, ContainingCollection<E> pre, ContainingCollection<E> post, IState preState, IState postState) {
         boolean[] result = new boolean[1];
-        Setable.<T, E> diff(preState.get(object, many), postState.get(object, many), added -> {
-            result[0] = pre.contains(added) == post.contains(added);
-        }, removed -> {
-            result[0] = pre.contains(removed) == post.contains(removed);
-        });
+        Setable.<T, E> diff(preState.get(object, many), postState.get(object, many), added -> result[0] = pre.contains(added) == post.contains(added), removed -> result[0] = pre.contains(removed) == post.contains(removed));
         return result[0];
     }
 
@@ -530,12 +517,14 @@ private <O, T> boolean changed(O object, Observed<O, T> observed, IState preStat
                 isChildChanged(observed, pre, preState, postState) || isChildChanged(observed, post, preState, postState);
     }
 
+    @SuppressWarnings("unused")
     private <O, T, E> boolean becameDerived(Observed<O, T> observed, E element, IState preState, IState postState) {
         return element instanceof Newable && ((Newable) element).dInitialConstruction().isDerived() && //
                 preState.get((Newable) element, Newable.D_ALL_DERIVATIONS).isEmpty() && //
                 !postState.get((Newable) element, Newable.D_ALL_DERIVATIONS).isEmpty();
     }
 
+    @SuppressWarnings("unused")
     private <O, T, E> boolean becameContained(Observed<O, T> observed, E element, IState preState, IState postState) {
         return element instanceof Newable && //
                 preState.get((Newable) element, Mutable.D_PARENT_CONTAINING) == null && //
@@ -560,12 +549,13 @@ private <O, T extends ContainingCollection<E>, E> boolean isRemoved(O object, Ob
                 (!forward || postState == state() || !observed.collection(postState.get(object, observed)).contains(element));
     }
 
+    @SuppressWarnings("unused")
     private <O, T> boolean isChangedBack(O object, Observed<O, T> observed, T pre, T post, IState preState, IState postState, boolean forward) {
         T before = preState.get(object, observed);
         return Objects.equals(before, post) && (!forward || (postState != state() && !Objects.equals(before, postState.get(object, observed))));
     }
 
-    private <T, O> void traceRippleOut(O object, Feature feature, Object post, Object result) {
+    private <O> void traceRippleOut(O object, Feature feature, Object post, Object result) {
         if (universeTransaction().getConfig().isTraceRippleOut()) {
             runNonObserving(() -> System.err.println(DclareTrace.getLineStart("DEFER", this) + mutable() + "." + observer() + //
                     " " + deferPriorityName() + " (" + object + "." + feature + "=" + result + "<-" + post + ")"));
@@ -573,6 +563,7 @@ private <T, O> void traceRippleOut(O object, Feature feature, Object post, Objec
     }
 
     private String deferPriorityName() {
+        //noinspection DataFlowIssue
         return defer.first(TRUE::equals).name().toUpperCase();
     }
 
@@ -636,7 +627,7 @@ private Object manyMatch(Mutable object, Observed observed, ContainingCollection
                             }
                         }
                         if (infos == null) {
-                            infos = Collection.concat(befores, afters).distinct().filter(Newable.class).map(n -> MatchInfo.of(n, this, object, observed)).toQualifiedSet(MatchInfo::newable);
+                            infos = Collection.concat(befores, afters).distinct().filter(Newable.class).map(n -> MatchInfo.of(n, this, object, observed)).asQualifiedSet(MatchInfo::newable);
                             postInfo = infos.get((Newable) after);
                         }
                         MatchInfo preInfo = infos.get((Newable) before);
@@ -673,7 +664,7 @@ private Object manyMatch(Mutable object, Observed observed, ContainingCollection
             afters = afters.sortedBy(e -> {
                 int i = ((List) bef).firstIndexOf(e);
                 return i < 0 ? ((List) aft).firstIndexOf(e) + bef.size() : i;
-            }).toList();
+            }).asList();
         }
         return !befores.equals(afters) ? rippleOut(object, observed, befores, afters) : afters;
     }
@@ -685,7 +676,7 @@ private void replace(MatchInfo replaced, MatchInfo replacing) {
         if (universeTransaction().getConfig().isTraceMatching()) {
             runNonObserving(() -> System.err.println(DclareTrace.getLineStart("MATCH", this) + mutable + "." + observer + " (" + replacing + "==" + replaced + ")"));
         }
-        if (Newable.D_INITIAL_CONSTRUCTION.get(replacing.newable()).isDirect()) {
+        if (Mutable.D_INITIAL_CONSTRUCTION.get(replacing.newable()).isDirect()) {
             super.set(replaced.newable(), Newable.D_REPLACING, Newable.D_REPLACING.getDefault(replaced.newable()), replacing.newable());
         }
         for (Construction cons : replaced.allDerivations()) {
diff --git a/src/main/java/org/modelingvalue/dclare/OneShot.java b/src/main/java/org/modelingvalue/dclare/OneShot.java
index 1f7c1bff..006b1858 100644
--- a/src/main/java/org/modelingvalue/dclare/OneShot.java
+++ b/src/main/java/org/modelingvalue/dclare/OneShot.java
@@ -15,6 +15,7 @@
 
 package org.modelingvalue.dclare;
 
+import org.modelingvalue.collections.Collection;
 import org.modelingvalue.collections.List;
 import org.modelingvalue.collections.Map;
 import org.modelingvalue.collections.Set;
@@ -30,7 +31,15 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Comparator;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 /**
  * This class will enable you to build a model in a dclare universe and then finish.
@@ -44,10 +53,12 @@
  */
 @SuppressWarnings("unused")
 public abstract class OneShot<U extends Universe> {
-    private static final boolean                                     TRACE_ONE_SHOT    = Boolean.getBoolean("TRACE_ONE_SHOT");
-    private static final MutationWrapper<Map<Class<?>, StateMap>>    STATE_MAP_CACHE   = new MutationWrapper<>(Map.of());
-    private static final MutationWrapper<Map<Class<?>, Set<Method>>> ALL_METHODS_CACHE = new MutationWrapper<>(Map.of());
-    private static       ContextPool                                 CONTEXT_POOL;
+    private static final boolean                                     TRACE_ONE_SHOT         = Boolean.getBoolean("TRACE_ONE_SHOT");
+    private static final String                                      TRACE_ONE_SHOT_OBJECT  = System.getProperty("TRACE_ONE_SHOT_OBJECT");
+    private static final String                                      TRACE_ONE_SHOT_SETABLE = System.getProperty("TRACE_ONE_SHOT_SETABLE");
+    private static final MutationWrapper<Map<Class<?>, StateMap>>    STATE_MAP_CACHE        = new MutationWrapper<>(Map.of());
+    private static final MutationWrapper<Map<Class<?>, Set<Method>>> ALL_METHODS_CACHE      = new MutationWrapper<>(Map.of());
+    private static final ContextPoolPool                             CONTEXT_POOL_POOL      = new ContextPoolPool();
 
     private final Class<?> cacheKey = getClass();
     private final U        universe;
@@ -64,7 +75,7 @@ public abstract class OneShot<U extends Universe> {
     public OneShot(U universe) {
         this.universe = universe;
 
-        List<String> cachingMethods = getAllMethodsOf(cacheKey).filter(m -> m.getAnnotation(OneShotAction.class).caching()).map(Method::getName).toList();
+        List<String> cachingMethods = getAllMethodsOf(cacheKey).filter(m -> m.getAnnotation(OneShotAction.class).caching()).map(Method::getName).asList();
         if (1 < cachingMethods.count()) {
             throw new IllegalStateException("the oneshot " + cacheKey.getSimpleName() + " has too many caching actions: " + cachingMethods.collect(Collectors.joining(", ")));
         }
@@ -94,16 +105,11 @@ public DclareConfig getConfig() {
      * @return the ContextPool that was created
      */
     public ContextPool getContextPool() {
-        synchronized (OneShot.class) {
-            if (CONTEXT_POOL == null) {
-                CONTEXT_POOL = ContextThread.createPool();
-            }
-        }
-        return CONTEXT_POOL;
+        return CONTEXT_POOL_POOL.getContextPool();
     }
 
-    public void shutdownContextPool(ContextPool contextPool) {
-        if (contextPool != CONTEXT_POOL) {
+    public void doneWithContextPool(ContextPool contextPool) {
+        if (!CONTEXT_POOL_POOL.doneWithContextPool(contextPool)) {
             contextPool.shutdownNow();
         }
     }
@@ -136,13 +142,13 @@ public State getEndState() {
                     UniverseTransaction universeTransaction = new UniverseTransaction(getUniverse(), contextPool, getConfig(), null, cachedStateMap);
                     long                t0                  = System.currentTimeMillis();
                     List<MyAction>      allActions          = getAllActions(runningFromCache);
-                    trace("TRACE_ONE_SHOT: %-6s %-40s actions=[%s]\n", "START", cacheKey.getSimpleName(), allActions.map(a -> a.id().toString()).collect(Collectors.joining(", ")));
+                    trace("START", "#actions=%d", allActions.size());
                     allActions.forEach(a -> a.putAndWaitForIdle(universeTransaction));
                     universeTransaction.stop();
                     endState = universeTransaction.waitForEnd();
-                    trace("TRACE_ONE_SHOT: %-6s %-40s duration=%5d ms\n", "DONE", cacheKey.getSimpleName(), System.currentTimeMillis() - t0);
+                    trace("DONE", "duration=%5d ms", System.currentTimeMillis() - t0);
                 } finally {
-                    shutdownContextPool(contextPool);
+                    doneWithContextPool(contextPool);
                 }
             }
             return endState;
@@ -154,10 +160,8 @@ public State getEndState() {
      *
      * @return the list of actions to perform
      */
-    private List<MyAction> getAllActions
-    (
-            boolean runningFromCache) {
-        return getAllMethodsOf(cacheKey).map(method -> new MyAction(method, runningFromCache)).sorted(Comparator.comparing(a -> a.id().toString())).toList();
+    private List<MyAction> getAllActions(boolean runningFromCache) {
+        return getAllMethodsOf(cacheKey).map(method -> new MyAction(method, runningFromCache)).sorted(Comparator.comparing(a -> a.id().toString())).asList();
     }
 
     private class MyAction extends Action<Universe> {
@@ -182,23 +186,36 @@ protected void putAndWaitForIdle(UniverseTransaction universeTransaction) {
             long    t00                = System.currentTimeMillis();
             boolean writeResultToCache = isCachingMethod && !runningFromCache;
             boolean skip               = isCachingMethod && runningFromCache;
-            if (!skip) {
+            if (skip) {
+                trace(" CACHE-SKIP", "%s", id());
+            } else {
+                trace(" >>ACTION", "%s", id());
                 State intermediateState = universeTransaction.putAndWaitForIdle(this);
+                traceDiff(intermediateState);
+                trace(" <<ACTION", "%s duration=%5d ms\n", id(), System.currentTimeMillis() - t00);
                 if (writeResultToCache) {
+                    trace(" CACHE-WRITE", "%s", id());
                     STATE_MAP_CACHE.update(a -> a.computeIfAbsent(cacheKey, __ -> intermediateState.getStateMap()));
                 }
             }
-            trace("TRACE_ONE_SHOT: %-6s %-40s     %-40s (%5d ms)%s%s\n", "ACTION", cacheKey.getSimpleName(), id(), System.currentTimeMillis() - t00, writeResultToCache ? " CACHE-WRITE" : "", skip ? " CACHE-SKIP" : "");
+        }
+
+        private static void traceDiff(State intermediateState) {
+            if (TRACE_ONE_SHOT_OBJECT != null || TRACE_ONE_SHOT_SETABLE != null) {
+                Predicate<String> objPred = TRACE_ONE_SHOT_OBJECT == null ? s -> true : Pattern.compile(TRACE_ONE_SHOT_OBJECT).asPredicate();
+                Predicate<String> setPred = TRACE_ONE_SHOT_SETABLE == null ? s -> true : Pattern.compile(TRACE_ONE_SHOT_SETABLE).asPredicate();
+                System.err.println("******************************State*************************************");
+                System.err.println(intermediateState.universeTransaction().emptyState().diffString(intermediateState, o -> objPred.test(o.toString()), s -> s.isTraced() && setPred.test(s.toString())));
+                System.err.println("************************************************************************");
+            }
         }
     }
 
-    private static Set<Method> getAllMethodsOf
-            (Class<?> clazz) {
+    private static Set<Method> getAllMethodsOf(Class<?> clazz) {
         return ALL_METHODS_CACHE.updateAndGet(a -> a.computeIfAbsent(clazz, __ -> computeAllMethodsOf(clazz))).get(clazz);
     }
 
-    private static Set<Method> computeAllMethodsOf
-            (Class<?> clazz) {
+    private static Set<Method> computeAllMethodsOf(Class<?> clazz) {
         Map<String, Method> map = Map.of();
         for (Class<?> c = clazz; c != Object.class; c = c.getSuperclass()) {
             for (Method m : c.getDeclaredMethods()) {
@@ -211,15 +228,208 @@ protected void putAndWaitForIdle(UniverseTransaction universeTransaction) {
                 }
             }
         }
-        return map.toValues().toSet();
+        return map.toValues().asSet();
     }
 
-    private static void trace
-            (String
-                     format, Object...
-                                     args) {
+    private void trace(String what, String format, Object... args) {
         if (TRACE_ONE_SHOT) {
-            System.err.printf(format, args);
+            System.err.printf("TRACE_ONE_SHOT: %-14s %-40s  -  %s\n", what, cacheKey.getSimpleName(), String.format(format, args));
+        }
+    }
+
+    private static class ContextPoolPool {
+        private static final boolean                              NO_POOL_POOL_TRACE             = Boolean.getBoolean("NO_POOL_POOL_TRACE");
+        private static final int                                  POOL_POOL_SIZE                 = Integer.getInteger("POOL_POOL_SIZE", Collection.PARALLELISM);
+        private static final int                                  POOL_POOL_ALARM_THRESHOLD_SEC  = Integer.getInteger("POOL_POOL_ALARM_THRESHOLD_SEC", 30);
+        private static final int                                  POOL_POOL_AQUIRE_TIMEOUT_SEC   = Integer.getInteger("POOL_POOL_AQUIRE_TIMEOUT_SEC", 30);
+        private static final int                                  POOL_POOL_MONITOR_INTERVAL_SEC = Integer.getInteger("POOL_POOL_MONITOR_INTERVAL_SEC", 60);
+        //
+        private final        BlockingQueue<PoolInfo>              idleQueue                      = new LinkedBlockingQueue<>(makePools());
+        private final        BlockingQueue<PoolInfo>              busyQueue                      = new LinkedBlockingQueue<>();
+        private final        AtomicReference<PoolPoolInfo>        poolPoolInfo                   = new AtomicReference<>(new PoolPoolInfo());
+        private final        java.util.Map<ContextPool, PoolInfo> poolInfoMap;
+
+        private static java.util.Collection<PoolInfo> makePools() {
+            return IntStream.range(0, POOL_POOL_SIZE)
+                            .mapToObj(i -> new PoolInfo())
+                            .toList();
+        }
+
+        public ContextPoolPool() {
+            trace("INIT");
+            poolInfoMap = makePoolInfoMap();
+            new PoolPoolMonitor(this).start();
+        }
+
+        private java.util.Map<ContextPool, PoolInfo> makePoolInfoMap() {
+            return idleQueue.stream().collect(Collectors.toMap(info -> info.pool, info -> info));
+        }
+
+        public ContextPool getContextPool() {
+            try {
+                PoolPoolInfo.preUpdate(poolPoolInfo);
+                trace("get");
+                long     t0   = System.nanoTime();
+                PoolInfo info = idleQueue.poll(POOL_POOL_AQUIRE_TIMEOUT_SEC, TimeUnit.SECONDS);
+                long     dt   = (System.nanoTime() - t0) / 1_000_000;
+                if (info == null) {
+                    trace("timeout");
+                    throw new RuntimeException("timeout after " + dt + " ms while waiting for ContextPool");
+                }
+                PoolPoolInfo.postUpdate(poolPoolInfo, dt);
+                info.start();
+                busyQueue.add(info);
+                trace(String.format("waited %6d ms", dt));
+                return info.pool;
+            } catch (InterruptedException e) {
+                throw new RuntimeException("interrupted while waiting for ContextPool", e);
+            }
+        }
+
+        public boolean doneWithContextPool(ContextPool pool) {
+            PoolInfo info = poolInfoMap.get(pool);
+            if (info == null) {
+                return false;
+            }
+            if (!busyQueue.remove(info)) {
+                trace("pool not busy");
+                throw new IllegalStateException("pool not busy");
+            }
+            info.stop();
+            idleQueue.add(info);
+            trace("done");
+            return true;
+        }
+
+        private void trace(String msg) {
+            if (!NO_POOL_POOL_TRACE) {
+                System.err.printf("TRACE: ContextPoolPool: [%-25s] %-25s: idle/busy=%3d/%3d: %s\n",
+                                  Thread.currentThread().getName(),
+                                  msg,
+                                  idleQueue.size(),
+                                  busyQueue.size(),
+                                  poolPoolInfo.get());
+            }
+        }
+
+        private void check() {
+            for (PoolInfo info : poolInfoMap.values()) {
+                if (info.busy) {
+                    long duration = info.duration();
+                    if (POOL_POOL_ALARM_THRESHOLD_SEC * 1000L < duration) {
+                        System.err.printf("ALARM: ContextPool probably stuck (busy for %-8d ms): %s\n", duration, info.pool);
+                    }
+                }
+            }
+        }
+
+        private static class PoolPoolMonitor extends Thread {
+            private final ContextPoolPool contextPoolPool;
+
+            private PoolPoolMonitor(ContextPoolPool contextPoolPool) {
+                super("PoolPoolMonitor");
+                setDaemon(true);
+                this.contextPoolPool = contextPoolPool;
+            }
+
+            @SuppressWarnings("BusyWait")
+            @Override
+            public void run() {
+                for (; ; ) {
+                    try {
+                        Thread.sleep(POOL_POOL_MONITOR_INTERVAL_SEC * 1000L);
+                        contextPoolPool.check();
+                    } catch (InterruptedException e) {
+                        System.err.println("WARNING PoolPoolMonitor interrupted!");
+                        return;
+                    }
+                }
+            }
+        }
+
+        private static class PoolInfo {
+            private final ContextPool pool;
+            private       boolean     busy;
+            private       long        startTick;
+            private       long        lastDuration;
+
+            public PoolInfo() {
+                pool = ContextThread.createPool();
+                // No-op tasks, just to get all Threads started
+                for (int i = 0; i < pool.getParallelism(); i++) {
+                    pool.execute(() -> {
+                    });
+                }
+            }
+
+            public void start() {
+                busy         = true;
+                lastDuration = 0;
+                startTick    = System.currentTimeMillis();
+            }
+
+            public void stop() {
+                busy         = false;
+                lastDuration = duration();
+                startTick    = 0;
+            }
+
+            public long duration() {
+                long t = startTick;
+                return t == 0 ? 0 : System.currentTimeMillis() - t;
+            }
+        }
+
+        private static class PoolPoolInfo {
+            private final long gets;
+            private final long immediates;
+            private final long waits;
+            private final long totalWaitTime;
+            private final long maxWaitTime;
+
+            public PoolPoolInfo() {
+                this.gets          = 0;
+                this.immediates    = 0;
+                this.waits         = 0;
+                this.totalWaitTime = 0;
+                this.maxWaitTime   = 0;
+            }
+
+            public static void preUpdate(AtomicReference<PoolPoolInfo> poolPoolInfo) {
+                update(poolPoolInfo, info -> new PoolPoolInfo(info.gets + 1, info.immediates, info.waits, info.totalWaitTime, info.maxWaitTime));
+            }
+
+            public static void postUpdate(AtomicReference<PoolPoolInfo> poolPoolInfo, long dt) {
+                update(poolPoolInfo, info -> new PoolPoolInfo(info.gets, info.immediates + (0 == dt ? 1 : 0), info.waits + (0 == dt ? 0 : 1), info.totalWaitTime + dt, Math.max(info.maxWaitTime, dt)));
+            }
+
+            private static void update(AtomicReference<PoolPoolInfo> poolPoolInfo, Function<PoolPoolInfo, PoolPoolInfo> f) {
+                for (; ; ) {
+                    PoolPoolInfo oldInfo = poolPoolInfo.get();
+                    PoolPoolInfo newInfo = f.apply(oldInfo);
+                    if (poolPoolInfo.compareAndSet(oldInfo, newInfo)) {
+                        break;
+                    }
+                }
+            }
+
+            private PoolPoolInfo(long gets, long immediates, long waits, long totalWaitTime, long maxWaitTime) {
+                this.gets          = gets;
+                this.immediates    = immediates;
+                this.waits         = waits;
+                this.totalWaitTime = totalWaitTime;
+                this.maxWaitTime   = maxWaitTime;
+            }
+
+            @Override
+            public String toString() {
+                return String.format("%4d gets (%4d immediates %4d waits %8d ms totalWait, %8d ms max-wait)",
+                                     gets,
+                                     immediates,
+                                     waits,
+                                     totalWaitTime,
+                                     maxWaitTime);
+            }
         }
     }
 }
diff --git a/src/main/java/org/modelingvalue/dclare/Priority.java b/src/main/java/org/modelingvalue/dclare/Priority.java
index c7527445..17ecff20 100644
--- a/src/main/java/org/modelingvalue/dclare/Priority.java
+++ b/src/main/java/org/modelingvalue/dclare/Priority.java
@@ -24,7 +24,7 @@
 import org.modelingvalue.collections.util.Internable;
 import org.modelingvalue.collections.util.Pair;
 
-public enum Priority implements LeafModifier, Internable {
+public enum Priority implements LeafModifier<Priority>, Internable {
 
     zero, // Running
 
@@ -48,7 +48,7 @@ public final static class Queued<T extends TransactionClass> extends Setable<Mut
         private final boolean actions;
 
         Queued(int i, boolean actions) {
-            super(Pair.of(i, actions), m -> Set.of(), null, null, null, SetableModifier.plumbing);
+            super(Pair.of(i, actions), m -> Set.of(), null, null, null, CoreSetableModifier.plumbing);
             this.actions = actions;
         }
 
@@ -88,20 +88,20 @@ public Concurrents(Priority start) {
         }
 
         public void init(T init) {
-            for (int i = 0; i < priorities.length; i++) {
-                priorities[i].init(init);
+            for (Concurrent<T> priority : priorities) {
+                priority.init(init);
             }
         }
 
         public void merge() {
-            for (int i = 0; i < priorities.length; i++) {
-                priorities[i].merge();
+            for (Concurrent<T> priority : priorities) {
+                priority.merge();
             }
         }
 
         public void clear() {
-            for (int i = 0; i < priorities.length; i++) {
-                priorities[i].clear();
+            for (Concurrent<T> priority : priorities) {
+                priority.clear();
             }
         }
 
@@ -162,8 +162,8 @@ public MutableState get(Priority priority) {
         }
 
         public void setState(State state) {
-            for (int i = 0; i < priorities.length; i++) {
-                priorities[i].setState(state);
+            for (MutableState priority : priorities) {
+                priority.setState(state);
             }
         }
 
diff --git a/src/main/java/org/modelingvalue/dclare/ReadOnly.java b/src/main/java/org/modelingvalue/dclare/ReadOnly.java
index 7276196a..ddf34ca6 100644
--- a/src/main/java/org/modelingvalue/dclare/ReadOnly.java
+++ b/src/main/java/org/modelingvalue/dclare/ReadOnly.java
@@ -17,7 +17,7 @@
 
 public class ReadOnly extends Leaf {
 
-    protected ReadOnly(Object id, LeafModifier... modifiers) {
+    protected ReadOnly(Object id, LeafModifier<?>... modifiers) {
         super(id, modifiers);
     }
 
diff --git a/src/main/java/org/modelingvalue/dclare/Setable.java b/src/main/java/org/modelingvalue/dclare/Setable.java
index 15010dae..b8f49280 100644
--- a/src/main/java/org/modelingvalue/dclare/Setable.java
+++ b/src/main/java/org/modelingvalue/dclare/Setable.java
@@ -15,8 +15,8 @@
 
 package org.modelingvalue.dclare;
 
+import static org.modelingvalue.dclare.CoreSetableModifier.symmetricOpposite;
 import static org.modelingvalue.dclare.Priority.one;
-import static org.modelingvalue.dclare.SetableModifier.symmetricOpposite;
 
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -24,6 +24,7 @@
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 
+import org.modelingvalue.collections.Collection;
 import org.modelingvalue.collections.ContainingCollection;
 import org.modelingvalue.collections.DefaultMap;
 import org.modelingvalue.collections.Entry;
@@ -41,43 +42,43 @@ public class Setable<O, T> extends Getable<O, T> {
 
     private static final Context<Boolean> MOVING                      = Context.of(false);
 
-    public static <C, V> Setable<C, V> of(Object id, V def, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, V def, SetableModifier<?>... modifiers) {
         return new Setable<>(id, c -> def, null, null, null, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier<?>... modifiers) {
         return new Setable<>(id, c -> def, null, null, changed, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, SetableModifier<?>... modifiers) {
         return new Setable<>(id, c -> def, opposite, null, null, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, Supplier<Setable<C, Set<?>>> scope, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, V def, QuadConsumer<LeafTransaction, C, V, V> changed, Supplier<Setable<C, Set<?>>> scope, SetableModifier<?>... modifiers) {
         return new Setable<>(id, c -> def, null, scope, changed, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, V def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, SetableModifier<?>... modifiers) {
         return new Setable<>(id, c -> def, opposite, scope, null, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, SetableModifier<?>... modifiers) {
         return new Setable<>(id, def, null, null, null, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, QuadConsumer<LeafTransaction, C, V, V> changed, SetableModifier<?>... modifiers) {
         return new Setable<>(id, def, null, null, changed, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, Supplier<Setable<?, ?>> opposite, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, Supplier<Setable<?, ?>> opposite, SetableModifier<?>... modifiers) {
         return new Setable<>(id, def, opposite, null, null, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, QuadConsumer<LeafTransaction, C, V, V> changed, Supplier<Setable<C, Set<?>>> scope, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, QuadConsumer<LeafTransaction, C, V, V> changed, Supplier<Setable<C, Set<?>>> scope, SetableModifier<?>... modifiers) {
         return new Setable<>(id, def, null, scope, changed, modifiers);
     }
 
-    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, SetableModifier... modifiers) {
+    public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<C, Set<?>>> scope, SetableModifier<?>... modifiers) {
         return new Setable<>(id, def, opposite, scope, null, modifiers);
     }
 
@@ -89,38 +90,47 @@ public static <C, V> Setable<C, V> of(Object id, Function<C, V> def, Supplier<Se
     private final Constant<T, Entry<Setable, Object>>    internal;
     @SuppressWarnings("rawtypes")
     private final Entry<Setable, Object>                 nullEntry;
+    private final Set<SetableModifier<?>>                modifierSet;
     private final boolean                                plumbing;
     private final boolean                                synthetic;
     private final boolean                                doNotMerge;
     private final boolean                                orphansAllowed;
     private final boolean                                preserved;
     private final boolean                                doNotClear;
+    private final Direction                              direction;
 
     private Boolean                                      isReference;
     private Constant<O, T>                               constant;
 
-    protected Setable(Object id, Function<O, T> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<O, Set<?>>> scope, QuadConsumer<LeafTransaction, O, T, T> changed, SetableModifier... modifiers) {
+    protected Setable(Object id, Function<O, T> def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<O, Set<?>>> scope, QuadConsumer<LeafTransaction, O, T, T> changed, SetableModifier<?>... modifiers) {
         super(id, def);
-        this.plumbing = SetableModifier.plumbing.in(modifiers);
-        this.containment = SetableModifier.containment.in(modifiers);
-        this.synthetic = SetableModifier.synthetic.in(modifiers);
+        this.modifierSet = Collection.of(modifiers).notNull().asSet();
+        this.plumbing = hasModifier(CoreSetableModifier.plumbing);
+        this.containment = hasModifier(CoreSetableModifier.containment);
+        this.synthetic = hasModifier(CoreSetableModifier.synthetic);
         this.changed = changed;
-        if (symmetricOpposite.in(modifiers)) {
-            if (opposite != null) {
-                throw new Error("The setable " + this + " is already a symetric-opposite");
-            } else {
-                this.opposite = () -> this;
-            }
-        } else {
-            this.opposite = opposite;
+        if (hasModifier(symmetricOpposite) && opposite != null) {
+            throw new Error("The setable " + this + " is already a symmetric-opposite");
         }
+        this.opposite = hasModifier(symmetricOpposite) ? () -> this : opposite;
         this.scope = scope;
         this.nullEntry = Entry.of(this, null);
         this.internal = this instanceof Constant ? null : Constant.of(Pair.of(this, "internalEntry"), v -> Entry.of(this, v));
-        this.doNotMerge = SetableModifier.doNotMerge.in(modifiers);
-        this.orphansAllowed = SetableModifier.orphansAllowed.in(modifiers);
-        this.preserved = SetableModifier.preserved.in(modifiers);
-        this.doNotClear = SetableModifier.doNotClear.in(modifiers);
+        this.doNotMerge = hasModifier(CoreSetableModifier.doNotMerge);
+        this.orphansAllowed = hasModifier(CoreSetableModifier.orphansAllowed);
+        this.preserved = hasModifier(CoreSetableModifier.preserved);
+        this.doNotClear = hasModifier(CoreSetableModifier.doNotClear);
+        Direction dir = getModifier(Direction.class);
+        this.direction = dir == null ? Direction.DEFAULT : dir;
+    }
+
+    public boolean hasModifier(SetableModifier<?> modifier) {
+        return modifierSet.contains(modifier);
+    }
+
+    @SuppressWarnings({"unused", "unchecked"})
+    public <SM extends SetableModifier<?>> SM getModifier(Class<SM> modifierClass) {
+        return (SM) FeatureModifier.ofClass(modifierClass, modifierSet);
     }
 
     @SuppressWarnings("rawtypes")
@@ -142,6 +152,10 @@ protected boolean deduplicate(T value) {
         return value instanceof ContainingCollection;
     }
 
+    public Direction direction() {
+        return direction;
+    }
+
     public boolean preserved() {
         return preserved;
     }
@@ -315,7 +329,7 @@ public static <T, E> void diff(T pre, T post, Consumer<E> added, Consumer<E> rem
     }
 
     public boolean checkConsistency() {
-        return !plumbing && (scope != null || checkForOrphans());
+        return !plumbing && !direction().isLazy() && (scope != null || checkForOrphans());
     }
 
     private boolean checkForOrphans() {
@@ -359,5 +373,4 @@ public Set<ConsistencyError> checkConsistency(State state, O object, T post) {
         }
         return errors;
     }
-
 }
diff --git a/src/main/java/org/modelingvalue/dclare/SetableModifier.java b/src/main/java/org/modelingvalue/dclare/SetableModifier.java
index 55e9ccce..010d2eb6 100644
--- a/src/main/java/org/modelingvalue/dclare/SetableModifier.java
+++ b/src/main/java/org/modelingvalue/dclare/SetableModifier.java
@@ -15,15 +15,5 @@
 
 package org.modelingvalue.dclare;
 
-public enum SetableModifier implements FeatureModifier<SetableModifier> {
-    symmetricOpposite,
-    containment,
-    mandatory,
-    synthetic,
-    plumbing,
-    durable,
-    doNotMerge,
-    orphansAllowed,
-    preserved,
-    doNotClear;
+public interface SetableModifier<M extends SetableModifier<?>> extends FeatureModifier<M> {
 }
diff --git a/src/main/java/org/modelingvalue/dclare/State.java b/src/main/java/org/modelingvalue/dclare/State.java
index ddefcd5e..9c27e778 100644
--- a/src/main/java/org/modelingvalue/dclare/State.java
+++ b/src/main/java/org/modelingvalue/dclare/State.java
@@ -274,6 +274,17 @@ public <R> R deriveIdentity(Supplier<R> supplier, int depth, Mutable contextMuta
         }
     }
 
+    public State deriveLazy() {
+        ConstantState derivationState = new ConstantState("LAZY", universeTransaction::handleException);
+        LazyDerivationTransaction tx = universeTransaction.lazyDerivation.openTransaction(universeTransaction);
+        try {
+            return tx.derive(() -> tx.derive(), this, derivationState);
+        } finally {
+            derivationState.stop();
+            universeTransaction.lazyDerivation.closeTransaction(tx);
+        }
+    }
+
     public String diffString(StateMap other) {
         return diffString(diff(other));
     }
@@ -309,7 +320,7 @@ private static String valueDiffString(Object a, Object b) {
         } else if (a instanceof List && b instanceof List) {
             List la = (List) a;
             List lb = (List) b;
-            if (la.filter(lb::contains).toList().equals(lb.filter(la::contains).toList())) {
+            if (la.filter(lb::contains).asList().equals(lb.filter(la::contains).asList())) {
                 // same order
                 return "\n          <+ " + la.removeAll(lb) + "\n          +> " + lb.removeAll(la);
             } else {
@@ -332,7 +343,7 @@ public static String shortValueDiffString(Object a, Object b) {
         } else if (a instanceof List && b instanceof List) {
             List la = (List) a;
             List lb = (List) b;
-            if (la.filter(lb::contains).toList().equals(lb.filter(la::contains).toList())) {
+            if (la.filter(lb::contains).asList().equals(lb.filter(la::contains).asList())) {
                 // same order
                 List removed = la.removeAll(lb);
                 List added = lb.removeAll(la);
diff --git a/src/main/java/org/modelingvalue/dclare/StateMap.java b/src/main/java/org/modelingvalue/dclare/StateMap.java
index e7374d03..f5d9a09f 100644
--- a/src/main/java/org/modelingvalue/dclare/StateMap.java
+++ b/src/main/java/org/modelingvalue/dclare/StateMap.java
@@ -169,7 +169,7 @@ public Collection<Entry<Object, Map<Setable, Pair<Object, Object>>>> diff(StateM
     public Collection<Entry<Object, Map<Setable, Pair<Object, Object>>>> diff(StateMap other, Predicate<Object> objectFilter, Predicate<Setable> setableFilter) {
         return map.diff(other.map()).filter(d1 -> objectFilter.test(d1.getKey())).map(d2 -> {
             DefaultMap<Setable, Object> map2 = d2.getValue().a();
-            Map<Setable, Pair<Object, Object>> diff = map2.diff(d2.getValue().b()).filter(d3 -> setableFilter.test(d3.getKey())).toMap(e -> e);
+            Map<Setable, Pair<Object, Object>> diff = map2.diff(d2.getValue().b()).filter(d3 -> setableFilter.test(d3.getKey())).asMap(e -> e);
             return diff.isEmpty() ? null : Entry.of(d2.getKey(), diff);
         }).notNull();
     }
diff --git a/src/main/java/org/modelingvalue/dclare/StateToJson.java b/src/main/java/org/modelingvalue/dclare/StateToJson.java
index b98b4411..cf086850 100644
--- a/src/main/java/org/modelingvalue/dclare/StateToJson.java
+++ b/src/main/java/org/modelingvalue/dclare/StateToJson.java
@@ -15,13 +15,6 @@
 
 package org.modelingvalue.dclare;
 
-import java.util.AbstractMap.SimpleEntry;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.function.Predicate;
-
 import org.modelingvalue.collections.Collection;
 import org.modelingvalue.collections.List;
 import org.modelingvalue.collections.QualifiedSet;
@@ -30,11 +23,18 @@
 import org.modelingvalue.dclare.sync.Util;
 import org.modelingvalue.json.ToJson;
 
+import java.util.AbstractMap.SimpleEntry;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.function.Predicate;
+
 @SuppressWarnings({"rawtypes", "unused"})
 public class StateToJson extends ToJson {
-    public static final String                             ID_FIELD_NAME     = "@id";
-    public static final String                             ID_REF_FIELD_NAME = "@idref";
-    public static final String                             NAME_FIELD_NAME   = "name";
+    public static final  String                            ID_FIELD_NAME     = "@id";
+    public static final  String                            ID_REF_FIELD_NAME = "@idref";
+    public static final  String                            NAME_FIELD_NAME   = "name";
     private static final Comparator<Entry<Object, Object>> FIELD_SORTER      = ((Comparator<Entry<Object, Object>>) (e1, e2) -> isNameOrId(e1) ? -1 : isNameOrId(e2) ? +1 : 0).thenComparing(e -> e.getKey().toString());
 
     private static boolean isNameOrId(Entry<Object, Object> e) {
@@ -70,7 +70,7 @@ protected boolean isMapType(Object o) {
     @Override
     protected Iterator<Object> getArrayIterator(Object o) {
         if (o instanceof Set) {
-            return (Iterator<Object>) ((Set) o).sorted(setSorter).toList().iterator();
+            return (Iterator<Object>) ((Set) o).sorted(setSorter).asList().iterator();
         } else {
             return super.getArrayIterator(o);
         }
@@ -80,25 +80,24 @@ protected Iterator<Object> getArrayIterator(Object o) {
     @Override
     protected Iterator<Entry<Object, Object>> getMapIterator(Object o) {
         List<Entry<Object, Object>> entries;
-        if (o instanceof Mutable) {
-            Mutable mutable = (Mutable) o;
+        if (o instanceof Mutable mutable) {
             Collection<Entry<Object, Object>> stream = mutable.dClass().dSetables() //
-                    .filter(getSetableFilter()) //
-                    .map(setable -> Pair.of(setable, state.get(mutable, (Setable) setable))) //
-                    .filter(pair -> !Objects.equals(pair.b(), ((Setable) pair.a()).getDefault(mutable))) //
-                    .map(p -> (Entry<Object, Object>) new SimpleEntry<>((Object) renderTag(p.a()), renderValue(o, p.a(), p.b()))) //
-                    .sorted(FIELD_SORTER);
+                                                              .filter(getSetableFilter()) //
+                                                              .map(setable -> Pair.of(setable, state.get(mutable, (Setable) setable))) //
+                                                              .filter(pair -> !Objects.equals(pair.b(), ((Setable) pair.a()).getDefault(mutable))) //
+                                                              .map(pair -> (Entry<Object, Object>) new SimpleEntry<>((Object) renderTag(pair.a()), renderValue(o, pair.a(), pair.b()))) //
+                                                              .sorted(FIELD_SORTER);
             if (renderIdFor(mutable)) {
                 Collection<Entry<Object, Object>> idEntry = Collection.of(new SimpleEntry<>(ID_FIELD_NAME, getId(mutable)));
                 stream = Collection.concat(idEntry, stream);
             }
-            entries = stream.toList();
+            entries = stream.asList();
         } else if (o instanceof QualifiedSet) {
             QualifiedSet<Object, Object> q = (QualifiedSet<Object, Object>) o;
             entries = q.toKeys() //
-                    .map(k -> (Entry<Object, Object>) new SimpleEntry<>(k, q.get(k))) //
-                    .sortedBy(e -> e.getKey().toString()) //
-                    .toList();
+                       .map(k -> (Entry<Object, Object>) new SimpleEntry<>(k, q.get(k))) //
+                       .sortedBy(e -> e.getKey().toString()) //
+                       .asList();
         } else {
             throw new RuntimeException("this should not be reachable");
         }
@@ -127,12 +126,14 @@ protected Object renderContainmentValue(Object o, Setable setable, Object value)
 
     @SuppressWarnings("unchecked")
     protected Object renderReferenceValue(Object o, Setable setable, Object value) {
-        if (value instanceof Mutable) {
+        if (value == null) {
+            value = "@@ERROR@NULL_REF@@";
+        } else if (value instanceof Mutable) {
             value = makeRef((Mutable) value);
         } else if (value instanceof List) {
-            value = ((List) value).map(v -> v instanceof Mutable ? makeRef((Mutable) v) : v).toList();
+            value = ((List) value).map(v -> v instanceof Mutable ? makeRef((Mutable) v) : v).asList();
         } else if (value instanceof Set) {
-            value = ((Set) value).map(v -> v instanceof Mutable ? makeRef((Mutable) v) : v).sorted(setSorter).toList();
+            value = ((Set) value).map(v -> v instanceof Mutable ? makeRef((Mutable) v) : v).sorted(setSorter).asList();
         } else if (!Util.PREFIX_MAP.containsKey(value.getClass())) {
             value = "@@ERROR@REF_TO_UNKNOWN_TYPE@" + value.getClass().getSimpleName() + "@" + value + "@@";
         }
@@ -141,7 +142,7 @@ protected Object renderReferenceValue(Object o, Setable setable, Object value) {
 
     protected QualifiedSet<String, String> makeRef(Mutable mutableValue) {
         if (!renderIdFor(mutableValue)) {
-            throw new IllegalArgumentException("json serialisation can not proceed: need to " + ID_REF_FIELD_NAME + " to mutable " + getId(mutableValue) + " that does not render its " + ID_FIELD_NAME);
+            throw new IllegalArgumentException("json serialisation can not proceed: need to " + ID_REF_FIELD_NAME + " to mutable " + getId(mutableValue) + " of class " + mutableValue.dClass() + " that does not render its " + ID_FIELD_NAME);
         }
         return QualifiedSet.of(__ -> ID_REF_FIELD_NAME, getId(mutableValue));
     }
diff --git a/src/main/java/org/modelingvalue/dclare/TransactionId.java b/src/main/java/org/modelingvalue/dclare/TransactionId.java
index 80e0d2be..0e26df90 100644
--- a/src/main/java/org/modelingvalue/dclare/TransactionId.java
+++ b/src/main/java/org/modelingvalue/dclare/TransactionId.java
@@ -18,8 +18,7 @@
 import org.modelingvalue.collections.util.Internable;
 
 public class TransactionId implements Internable {
-
-    public static final TransactionId of(long number) {
+    public static TransactionId of(long number) {
         return new TransactionId(number);
     }
 
@@ -35,7 +34,7 @@ public long number() {
 
     @Override
     public String toString() {
-        return "TX" + Long.toString(number);
+        return "TX" + number;
     }
 
     @Override
@@ -50,8 +49,7 @@ public boolean equals(Object obj) {
         } else if (!(obj instanceof TransactionId)) {
             return false;
         } else {
-            TransactionId other = (TransactionId) obj;
-            return number == other.number;
+            return number == ((TransactionId) obj).number;
         }
     }
 
diff --git a/src/main/java/org/modelingvalue/dclare/TypeWrapper.java b/src/main/java/org/modelingvalue/dclare/TypeWrapper.java
new file mode 100644
index 00000000..f5921fe4
--- /dev/null
+++ b/src/main/java/org/modelingvalue/dclare/TypeWrapper.java
@@ -0,0 +1,117 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// (C) Copyright 2018-2023 Modeling Value Group B.V. (http://modelingvalue.org)                                        ~
+//                                                                                                                     ~
+// Licensed under the GNU Lesser General Public License v3.0 (the 'License'). You may not use this file except in      ~
+// compliance with the License. You may obtain a copy of the License at: https://choosealicense.com/licenses/lgpl-3.0  ~
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on ~
+// an 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  ~
+// specific language governing permissions and limitations under the License.                                          ~
+//                                                                                                                     ~
+// Maintainers:                                                                                                        ~
+//     Wim Bast, Tom Brus, Ronald Krijgsheld                                                                           ~
+// Contributors:                                                                                                       ~
+//     Arjan Kok, Carel Bast                                                                                           ~
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+package org.modelingvalue.dclare;
+
+import java.util.Optional;
+
+import org.modelingvalue.collections.List;
+import org.modelingvalue.collections.util.IdentifiedBy;
+import org.modelingvalue.collections.util.Pair;
+
+public interface TypeWrapper {
+
+    Constant<TypeWrapper, List<TypeWrapper>> SUPERS = Constant.of(Pair.of("SUPERS", TypeWrapper.class), TypeWrapper::computeSupers);
+
+    List<TypeWrapper> computeSupers();
+
+    default List<TypeWrapper> supers() {
+        return SUPERS.get(this);
+    }
+
+    Constant<Pair<TypeWrapper, TypeWrapper>, Boolean> IS_ASSIGNABLE_TO = Constant.of(Pair.of("IS_ASSIGNABLE_TO", TypeWrapper.class), TypeWrapper::isAssignableTo);
+
+    private static boolean isAssignableTo(Pair<TypeWrapper, TypeWrapper> pair) {
+        var sub = pair.a();
+        var sup = pair.b();
+        return sub.equals(sup) || sub.supers().anyMatch(t -> IS_ASSIGNABLE_TO.get(Pair.of(t, sup)));
+    }
+
+    default boolean isAssignableTo(TypeWrapper type) {
+        return IS_ASSIGNABLE_TO.get(Pair.of(this, type));
+    }
+
+    default boolean isSuperOf(TypeWrapper sub) {
+        if (this.equals(sub)) {
+            return false;
+        } else {
+            return sub.isAssignableTo(this);
+        }
+    }
+
+    default boolean isSubOf(TypeWrapper sup) {
+        if (this.equals(sup)) {
+            return false;
+        } else {
+            return this.isAssignableTo(sup);
+        }
+    }
+
+    Constant<TypeWrapper, List<TypeWrapper>> LINEARIZATION = Constant.of(Pair.of("LINEARIZATION", TypeWrapper.class), tw -> TypeWrapper.linearization(tw));
+
+    private static List<TypeWrapper> linearization(TypeWrapper type) {
+        var supers = type.supers();
+        var ls = supers.map(LINEARIZATION::get).asList();
+        return merge(List.of(type), ls, supers);
+    }
+
+    private static List<TypeWrapper> merge(List<TypeWrapper> result, List<List<TypeWrapper>> supers, List<TypeWrapper> immediates) {
+        var combined = supers.add(immediates).filter(m -> !m.isEmpty()).asList();
+        if (combined.isEmpty()) {
+            return result;
+        } else {
+            var supersFiltered = supers.filter(m -> !m.isEmpty()).asList();
+            TypeWrapper candidate = getMergeCandidate(combined).or(() -> getMergeCandidate(supersFiltered)).orElseGet(() -> combined.get(0).get(0));
+            return merge(result.add(candidate), supersFiltered.map(l -> l.remove(candidate)).asList(), immediates.remove(candidate));
+        }
+    }
+
+    private static Optional<TypeWrapper> getMergeCandidate(List<List<TypeWrapper>> merge) {
+        for (var list : merge) {
+            var head = list.get(0);
+            if (merge.noneMatch(l -> l.lastIndexOf(head) > 0)) {
+                return Optional.of(head);
+            }
+        }
+        return Optional.empty();
+    }
+
+    default List<TypeWrapper> linearization() {
+        return LINEARIZATION.get(this);
+    }
+
+    class ObjectType extends IdentifiedBy<Class<?>> implements TypeWrapper {
+
+        public ObjectType(Class<?> clazz) {
+            super(clazz);
+        }
+
+        @Override
+        public List<TypeWrapper> computeSupers() {
+            if (this.id() == Object.class) {
+                return List.of();
+            } else {
+                var sups = List.<Class<?>, TypeWrapper> of(ObjectType::new, this.id().getInterfaces());
+                return sups.add(this.id().getSuperclass() == null ? new ObjectType(Object.class) : new ObjectType(this.id().getSuperclass()));
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "object<" + this.id().toString() + ">";
+        }
+    }
+
+}
diff --git a/src/main/java/org/modelingvalue/dclare/UniverseTransaction.java b/src/main/java/org/modelingvalue/dclare/UniverseTransaction.java
index 6d1a151f..142b47e5 100644
--- a/src/main/java/org/modelingvalue/dclare/UniverseTransaction.java
+++ b/src/main/java/org/modelingvalue/dclare/UniverseTransaction.java
@@ -52,6 +52,7 @@ public class UniverseTransaction extends MutableTransaction {
     protected final Concurrent<ReusableTransaction<Mutable, MutableTransaction>>                       mutableTransactions     = Concurrent.of(() -> new ReusableTransaction<>(this));
     protected final Concurrent<ReusableTransaction<ReadOnly, ReadOnlyTransaction>>                     readOnlys               = Concurrent.of(() -> new ReusableTransaction<>(this));
     protected final Concurrent<ReusableTransaction<Derivation, DerivationTransaction>>                 derivations             = Concurrent.of(() -> new ReusableTransaction<>(this));
+    protected final Concurrent<ReusableTransaction<LazyDerivation, LazyDerivationTransaction>>         lazyDerivations         = Concurrent.of(() -> new ReusableTransaction<>(this));
     protected final Concurrent<ReusableTransaction<IdentityDerivation, IdentityDerivationTransaction>> identityDerivations     = Concurrent.of(() -> new ReusableTransaction<>(this));
     protected final Concurrent<ReusableTransaction<NonCheckingObserver<?>, NonCheckingTransaction>>    nonCheckingTransactions = Concurrent.of(() -> new ReusableTransaction<>(this));
     //
@@ -62,6 +63,7 @@ public class UniverseTransaction extends MutableTransaction {
     private final Action<Universe>                                                                     commit                  = Action.of("$commit");
     private final Action<Universe>                                                                     clearOrphans            = Action.of("$clearOrphans", this::clearOrphans);
     private final Action<Universe>                                                                     checkConsistency        = Action.of("$checkConsistency", this::checkConsistency);
+    private final Action<Universe>                                                                     deriveLazy              = Action.of("$deriveLazy", this::deriveLazy);
     //
     protected final BlockingQueue<Action<Universe>>                                                    inQueue;
     private final BlockingQueue<State>                                                                 resultQueue             = new LinkedBlockingQueue<>(1);                          //TODO wire onto MoodManager
@@ -70,6 +72,7 @@ public class UniverseTransaction extends MutableTransaction {
     protected final ReadOnly                                                                           runOnState              = new ReadOnly(this, Priority.one);
     protected final Derivation                                                                         derivation              = new Derivation(this, Priority.one);
     protected final IdentityDerivation                                                                 identityDerivation      = new IdentityDerivation(this, Priority.one);
+    protected final LazyDerivation                                                                     lazyDerivation          = new LazyDerivation(this, Priority.one);
     private final UniverseStatistics                                                                   universeStatistics;
     protected final AtomicReference<Set<Throwable>>                                                    errors                  = new AtomicReference<>(Set.of());
     private final AtomicReference<Set<Throwable>>                                                      inconsistencies         = new AtomicReference<>(Set.of());
@@ -88,6 +91,7 @@ public class UniverseTransaction extends MutableTransaction {
     private List<State>                                                                                history                 = List.of();
     private List<State>                                                                                future                  = List.of();
     private State                                                                                      preState;
+    private State                                                                                      postState;
     private State                                                                                      preOrphansState;
     private ConstantState                                                                              tmpConstants;
     private State                                                                                      state;
@@ -409,6 +413,9 @@ protected State run(State state) {
                 }
                 state = incrementChangeId(universe(), state);
                 state = super.run(state);
+                if (postState == null) {
+                    postState = state;
+                }
                 if (!killed && orphansDetected.get() == Boolean.TRUE) {
                     preOrphansState = startState(Priority.INNER).preState();
                     state = trigger(state, universe(), clearOrphans, Priority.INNER);
@@ -436,6 +443,7 @@ protected State run(State state) {
             } while (priority != null);
             return state;
         } finally {
+            postState = null;
             preStartStates.setState(emptyState);
             startStates.setState(emptyState);
             preOrphansState = null;
@@ -493,7 +501,7 @@ public State lastState() {
     protected void handleExceptions(Set<Throwable> exceptions) {
         errors.updateAndGet(exceptions::addAll);
         if (config.isTraceUniverse()) {
-            List<Throwable> list = errors.get().sorted(this::compareThrowable).toList();
+            List<Throwable> list = errors.get().sorted(this::compareThrowable).asList();
             System.err.println(DclareTrace.getLineStart("DCLARE", this) + list.size() + " EXCEPTION(S) " + this);
             list.first().printStackTrace();
         }
@@ -507,7 +515,7 @@ public final void handleException(Throwable t) {
     public void throwIfError() {
         Set<Throwable> es = errors.get();
         if (!es.isEmpty()) {
-            List<Throwable> list = es.sorted(this::compareThrowable).toList();
+            List<Throwable> list = es.sorted(this::compareThrowable).asList();
             throw new Error("Error in engine " + state.get(() -> list.first().getMessage()), list.first());
         }
     }
@@ -601,7 +609,7 @@ protected void clearOrphans(Universe universe) {
         State postState = tx.state();
         Set<Mutable> orphans = preOrphansState.diff(postState, o -> {
             return o instanceof Mutable && ((Mutable) o).dIsOrphan(postState) && !tx.toBeCleared((Mutable) o).isEmpty();
-        }).map(e -> (Mutable) e.getKey()).toSet();
+        }).map(e -> (Mutable) e.getKey()).asSet();
         orphansDetected.set(!orphans.isEmpty());
         orphans.forEach(tx::clearOrphan);
     }
@@ -710,6 +718,18 @@ private void commit(State state, boolean timeTraveling, Iterator<ImperativeTrans
         }
     }
 
+    public void deriveLazy() {
+        put(deriveLazy);
+
+    }
+
+    protected void deriveLazy(Universe universe) {
+        ActionTransaction current = (ActionTransaction) LeafTransaction.getCurrent();
+        State pre = current.state();
+        State post = pre.deriveLazy();
+        current.setState(post);
+    }
+
     public void commit() {
         put(commit);
     }
@@ -731,6 +751,10 @@ public State preState() {
         return preState;
     }
 
+    public State postState() {
+        return postState;
+    }
+
     public State currentState() {
         return state;
     }
diff --git a/src/main/java/org/modelingvalue/dclare/ex/ConsistencyError.java b/src/main/java/org/modelingvalue/dclare/ex/ConsistencyError.java
index e3170d3e..0b7613ce 100644
--- a/src/main/java/org/modelingvalue/dclare/ex/ConsistencyError.java
+++ b/src/main/java/org/modelingvalue/dclare/ex/ConsistencyError.java
@@ -19,22 +19,27 @@
 
 @SuppressWarnings({"serial", "unused"})
 public abstract class ConsistencyError extends RuntimeException implements Comparable<ConsistencyError> {
-
     private final Object  object;
     private final Feature feature;
     private final int     severity;
 
     protected ConsistencyError(Object object, Feature feature, int severity, String message) {
         super(message);
-        this.object = object;
-        this.feature = feature;
+        this.object   = object;
+        this.feature  = feature;
         this.severity = severity;
     }
 
     protected ConsistencyError(Object object, Feature feature, int severity, Throwable t) {
         super(t);
-        this.object = object;
-        this.feature = feature;
+        this.object   = object;
+        this.feature  = feature;
+        this.severity = severity;
+    }
+
+    protected ConsistencyError(Object object, Feature feature, int severity) {
+        this.object   = object;
+        this.feature  = feature;
         this.severity = severity;
     }
 
@@ -52,7 +57,6 @@ public Feature getFeature() {
 
     @Override
     public int compareTo(ConsistencyError o) {
-        return severity < o.severity ? -1 : severity > o.severity ? 1 : 0;
+        return Integer.compare(severity, o.severity);
     }
-
 }
diff --git a/src/main/java/org/modelingvalue/dclare/ex/CycleInParentChainException.java b/src/main/java/org/modelingvalue/dclare/ex/CycleInParentChainException.java
new file mode 100644
index 00000000..bbe3a323
--- /dev/null
+++ b/src/main/java/org/modelingvalue/dclare/ex/CycleInParentChainException.java
@@ -0,0 +1,39 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// (C) Copyright 2018-2023 Modeling Value Group B.V. (http://modelingvalue.org)                                        ~
+//                                                                                                                     ~
+// Licensed under the GNU Lesser General Public License v3.0 (the 'License'). You may not use this file except in      ~
+// compliance with the License. You may obtain a copy of the License at: https://choosealicense.com/licenses/lgpl-3.0  ~
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on ~
+// an 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the  ~
+// specific language governing permissions and limitations under the License.                                          ~
+//                                                                                                                     ~
+// Maintainers:                                                                                                        ~
+//     Wim Bast, Tom Brus, Ronald Krijgsheld                                                                           ~
+// Contributors:                                                                                                       ~
+//     Arjan Kok, Carel Bast                                                                                           ~
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+package org.modelingvalue.dclare.ex;
+
+import org.modelingvalue.collections.List;
+import org.modelingvalue.dclare.Mutable;
+import org.modelingvalue.dclare.Setable;
+
+import java.io.Serial;
+
+public class CycleInParentChainException extends ConsistencyError {
+    @Serial
+    private static final long serialVersionUID = -8866815750182251938L;
+
+    private final List<Mutable> chain;
+
+    public CycleInParentChainException(Object object, Setable<?, ?> setable, List<Mutable> chain) {
+        super(object, setable, 10);
+        this.chain = chain;
+    }
+
+    @Override
+    public String getMessage() {
+        return "cycle (#" + (chain.size() - 1) + ") detected in parent chain while getting property '" + getFeature() + "' of object '" + getObject() + "' chain=" + chain;
+    }
+}
diff --git a/src/main/java/org/modelingvalue/dclare/sync/Converters.java b/src/main/java/org/modelingvalue/dclare/sync/Converters.java
index 60627a0b..dddd7998 100644
--- a/src/main/java/org/modelingvalue/dclare/sync/Converters.java
+++ b/src/main/java/org/modelingvalue/dclare/sync/Converters.java
@@ -281,7 +281,7 @@ public String serialize(List<?> l) {
         @Override
         public List<?> deserialize(String string) {
             List<Object> l = (List<Object>) JsonIC.fromJson(string);
-            return l.map(e -> getPool().deserialize(e.toString())).toList();
+            return l.map(e -> getPool().deserialize(e.toString())).asList();
         }
     }
 
@@ -300,7 +300,7 @@ public String serialize(Set<?> s) {
         @Override
         public Set<?> deserialize(String string) {
             List<Object> l = (List<Object>) JsonIC.fromJson(string);
-            return l.map(e -> getPool().deserialize(e.toString())).toSet();
+            return l.map(e -> getPool().deserialize(e.toString())).asSet();
         }
     }
 
@@ -318,7 +318,7 @@ public String serialize(Map<?, ?> m, Object context) {
         @Override
         public Map<?, ?> deserialize(String string) {
             Map<?, ?> m = (Map<?, ?>) JsonIC.fromJson(string);
-            return m.toMap(e -> Entry.of(getPool().deserialize(e.getKey().toString()), getPool().deserialize(e.getValue().toString())));
+            return m.asMap(e -> Entry.of(getPool().deserialize(e.getKey().toString()), getPool().deserialize(e.getValue().toString())));
         }
     }
 }
diff --git a/src/main/java/org/modelingvalue/dclare/sync/DeltaAdaptor.java b/src/main/java/org/modelingvalue/dclare/sync/DeltaAdaptor.java
index 00f6bbac..b7ed01d8 100644
--- a/src/main/java/org/modelingvalue/dclare/sync/DeltaAdaptor.java
+++ b/src/main/java/org/modelingvalue/dclare/sync/DeltaAdaptor.java
@@ -118,7 +118,7 @@ public String poll(long timeout) {
      */
     @SuppressWarnings({"rawtypes", "unchecked"})
     protected void queueDelta(State pre, State post, Boolean last, DefaultMap<Object, Set<Setable>> setted) {
-        Map<Object, Map<Setable, Pair<Object, Object>>> deltaMap = pre.diff(post, getObjectFilter(), (Predicate<Setable>) (Object) helper.setableFilter()).toMap(e1 -> e1);
+        Map<Object, Map<Setable, Pair<Object, Object>>> deltaMap = pre.diff(post, getObjectFilter(), (Predicate<Setable>) (Object) helper.setableFilter()).asMap(e1 -> e1);
         if (!deltaMap.isEmpty()) {
             try {
                 deltaQueue.put(new ToJsonDeltas(deltaMap).render());
diff --git a/src/main/java/org/modelingvalue/dclare/sync/SerialisationPool.java b/src/main/java/org/modelingvalue/dclare/sync/SerialisationPool.java
index f875ec7c..41e03450 100644
--- a/src/main/java/org/modelingvalue/dclare/sync/SerialisationPool.java
+++ b/src/main/java/org/modelingvalue/dclare/sync/SerialisationPool.java
@@ -105,11 +105,11 @@ public SerialisationPool(Converter<?>... converters) {
     }
 
     public SerialisationPool(Collection<Converter<?>> converters) {
-        List<Converter<?>> conv = converters.toList();
+        List<Converter<?>> conv = converters.asList();
         sanityCheck(conv);
         conv.forEach(c -> c.setPool(this));
-        deserialiseMap = conv.toMap(c -> Entry.of(c.getPrefix(), c));
-        serializeMap = conv.toMap(c -> Entry.of(c.getClazz(), c));
+        deserialiseMap = conv.asMap(c -> Entry.of(c.getPrefix(), c));
+        serializeMap = conv.asMap(c -> Entry.of(c.getClazz(), c));
     }
 
     @SuppressWarnings("DataFlowIssue")
@@ -119,13 +119,13 @@ private void sanityCheck(List<Converter<?>> conv) {
             int maxLength = conv.mapToInt(c -> c.getClazz().getName().length()).max().orElse(0);
             conv.sequential().sorted(Comparator.comparing(a -> a.getClazz().getName())).forEach(c -> System.err.printf("  - %-" + maxLength + "s '%s%s'\n", c.getClazz().getName(), c.getPrefix(), Converter.DELIMITER));
         }
-        List<List<String>> doublePrefixes = Collection.of(conv.map(Converter::getPrefix).collect(Collectors.groupingBy(x -> x)).values().stream().filter(l -> l.size() != 1).map(List::of)).toList();
+        List<List<String>> doublePrefixes = Collection.of(conv.map(Converter::getPrefix).collect(Collectors.groupingBy(x -> x)).values().stream().filter(l -> l.size() != 1).map(List::of)).asList();
         if (!doublePrefixes.isEmpty()) {
             throw problem("a SerialisationPool can not hold Converters with the same prefix: " + doublePrefixes.map(l -> l.get(0)).collect(Collectors.toList()));
         }
         // NB: keep this next var separate to avoid java compiler error:
         Collection<List<? extends Class<?>>> avoidCompilerError = Collection.of(conv.map(Converter::getClazz).collect(Collectors.groupingBy(x -> x)).values().stream().filter(l -> l.size() != 1).map(List::of));
-        List<List<? extends Class<?>>> doubleClazzes = avoidCompilerError.toList();
+        List<List<? extends Class<?>>> doubleClazzes = avoidCompilerError.asList();
         if (!doubleClazzes.isEmpty()) {
             throw problem("a SerialisationPool can not hold Converters with the same class: " + doubleClazzes.map(l -> l.get(0)).collect(Collectors.toList()));
         }
diff --git a/src/test/java/org/modelingvalue/dclare/test/DclareTests.java b/src/test/java/org/modelingvalue/dclare/test/DclareTests.java
index 376a647f..073ba3eb 100644
--- a/src/test/java/org/modelingvalue/dclare/test/DclareTests.java
+++ b/src/test/java/org/modelingvalue/dclare/test/DclareTests.java
@@ -39,8 +39,8 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.modelingvalue.dclare.SetableModifier.containment;
-import static org.modelingvalue.dclare.SetableModifier.mandatory;
+import static org.modelingvalue.dclare.CoreSetableModifier.containment;
+import static org.modelingvalue.dclare.CoreSetableModifier.mandatory;
 import static org.modelingvalue.dclare.test.support.Shared.THE_POOL;
 import static org.modelingvalue.dclare.test.support.Shared.printState;
 
@@ -306,16 +306,16 @@ public void rippleOutTest() {
         TestMutable                              two      = TestMutable.of(2, clazz);
         TestMutableClass universeClass = TestMutableClass.of("Universe", children, begin, end).observe(u -> {
             List<TestMutable> list   = children.get(u);
-            List<TestMutable> before = list.exclude(property::get).toList();
+            List<TestMutable> before = list.exclude(property::get).asList();
             begin.set(u, before);
         }).observe(u -> {
             List<TestMutable> list  = children.get(u);
-            List<TestMutable> after = list.filter(property::get).toList();
+            List<TestMutable> after = list.filter(property::get).asList();
             end.set(u, after);
         }).observe(u -> {
             List<TestMutable> before = begin.get(u);
             List<TestMutable> after  = end.get(u);
-            children.set(u, Collection.concat(before, after).distinct().toList());
+            children.set(u, Collection.concat(before, after).distinct().asList());
         }).observe(u -> {
             List<TestMutable> list = children.get(u);
             if (list.isEmpty()) {
diff --git a/src/test/java/org/modelingvalue/dclare/test/NewableTests.java b/src/test/java/org/modelingvalue/dclare/test/NewableTests.java
index af79ee00..23da1cd3 100644
--- a/src/test/java/org/modelingvalue/dclare/test/NewableTests.java
+++ b/src/test/java/org/modelingvalue/dclare/test/NewableTests.java
@@ -15,17 +15,6 @@
 
 package org.modelingvalue.dclare.test;
 
-import static org.junit.jupiter.api.Assertions.*;
-import static org.modelingvalue.dclare.SetableModifier.*;
-import static org.modelingvalue.dclare.test.support.Shared.THE_POOL;
-import static org.modelingvalue.dclare.test.support.TestNewable.create;
-import static org.modelingvalue.dclare.test.support.TestNewable.n;
-
-import java.util.Objects;
-import java.util.Optional;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Consumer;
-
 import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.RepetitionInfo;
 import org.junit.jupiter.api.Test;
@@ -39,7 +28,15 @@
 import org.modelingvalue.collections.util.Concurrent;
 import org.modelingvalue.collections.util.Pair;
 import org.modelingvalue.collections.util.StatusProvider.StatusIterator;
-import org.modelingvalue.dclare.*;
+import org.modelingvalue.dclare.DclareConfig;
+import org.modelingvalue.dclare.Direction;
+import org.modelingvalue.dclare.LeafTransaction;
+import org.modelingvalue.dclare.Newable;
+import org.modelingvalue.dclare.Observed;
+import org.modelingvalue.dclare.Setable;
+import org.modelingvalue.dclare.State;
+import org.modelingvalue.dclare.Universe;
+import org.modelingvalue.dclare.UniverseTransaction;
 import org.modelingvalue.dclare.UniverseTransaction.Status;
 import org.modelingvalue.dclare.test.support.TestMutable;
 import org.modelingvalue.dclare.test.support.TestMutableClass;
@@ -47,6 +44,22 @@
 import org.modelingvalue.dclare.test.support.TestNewableClass;
 import org.modelingvalue.dclare.test.support.TestUniverse;
 
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.modelingvalue.dclare.CoreSetableModifier.containment;
+import static org.modelingvalue.dclare.CoreSetableModifier.mandatory;
+import static org.modelingvalue.dclare.CoreSetableModifier.symmetricOpposite;
+import static org.modelingvalue.dclare.CoreSetableModifier.synthetic;
+import static org.modelingvalue.dclare.test.support.Shared.THE_POOL;
+import static org.modelingvalue.dclare.test.support.TestNewable.create;
+import static org.modelingvalue.dclare.test.support.TestNewable.n;
+
 @SuppressWarnings("OptionalGetWithoutIsPresent")
 public class NewableTests {
 
@@ -125,21 +138,21 @@ public State bidirectional(DclareConfig config) {
         Direction b2a = Direction.of("B2A", a2b);
 
         U.observe(cs, u -> {
-            List<TestNewable> bs = cs.get(u).filter(B::isInstance).toList();
-            return Collection.concat(bs.map(ar::get), bs).toList();
+            List<TestNewable> bs = cs.get(u).filter(B::isInstance).asList();
+            return Collection.concat(bs.map(ar::get), bs).asList();
         }, b2a).observe(cs, u -> {
-            List<TestNewable> as = cs.get(u).filter(A::isInstance).toList();
-            return Collection.concat(as, as.map(br::get)).toList();
+            List<TestNewable> as = cs.get(u).filter(A::isInstance).asList();
+            return Collection.concat(as, as.map(br::get)).asList();
         }, a2b);
 
         A.observe(br, a -> create(B, x -> x.//
                 observe(n, b -> n.get(a), a2b).//
-                observe(bcs, b -> acs.get(a).map(br::get).toSet(), a2b).//
+                observe(bcs, b -> acs.get(a).map(br::get).asSet(), a2b).//
                 observe(bcr, b -> acr.get(a) != null ? br.get(acr.get(a)) : null, a2b))//
                 , a2b);
         B.observe(ar, b -> create(A, x -> x.//
                 observe(n, a -> n.get(b), b2a). //
-                observe(acs, a -> bcs.get(b).map(ar::get).toSet(), b2a). //
+                observe(acs, a -> bcs.get(b).map(ar::get).asSet(), b2a). //
                 observe(acr, a -> bcr.get(b) != null ? ar.get(bcr.get(b)) : null, b2a))//
                 , b2a);
         AC.observe(br, ac -> create(BC, x -> x.//
@@ -154,11 +167,11 @@ public State bidirectional(DclareConfig config) {
 
         Concurrent<Set<TestNewable>> created = run(utx, "init", c -> {
 
+            TestNewable a0 = c.create(A);
+            TestNewable b0 = c.create(B);
+            TestNewable a1 = c.create(A);
+            TestNewable b1 = c.create(B);
             if (FULL) {
-                TestNewable a0 = c.create(A);
-                TestNewable b0 = c.create(B);
-                TestNewable a1 = c.create(A);
-                TestNewable b1 = c.create(B);
                 TestNewable a2 = c.create(A);
                 TestNewable b2 = c.create(B);
                 TestNewable a3 = c.create(A);
@@ -207,10 +220,6 @@ public State bidirectional(DclareConfig config) {
                 n.set(ac5, "t");
                 n.set(bc5, "t");
             } else {
-                TestNewable a0 = c.create(A);
-                TestNewable b0 = c.create(B);
-                TestNewable a1 = c.create(A);
-                TestNewable b1 = c.create(B);
                 cs.set(universe, List.of(a0, b0, a1, b1));
                 n.set(a0, "x");
                 n.set(b0, "x");
@@ -245,7 +254,7 @@ public State bidirectional(DclareConfig config) {
         }
 
         result.run(() -> {
-            Set<TestNewable> objects = result.getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = result.getObjects(TestNewable.class).asSet();
             Set<TestNewable> news = created.result();
             Set<TestNewable> lost = news.removeAll(objects);
             assertEquals(Set.of(), lost);
@@ -413,11 +422,11 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
         Direction fb2ooDir = Direction.of("FB2OO", oo2fbDir);
 
         if (oo2fb) {
-            U.observe(fbms, u -> ooms.get(u).map(mfbm::get).toSet(), oo2fbDir);
+            U.observe(fbms, u -> ooms.get(u).map(mfbm::get).asSet(), oo2fbDir);
             OOM.observe(mfbm, oo -> create(FBM, x -> x. //
                     observe(n, fb -> n.get(oo), oo2fbDir). //
-                    observe(ots, fb -> cls.get(oo).map(mobt::get).toSet(), oo2fbDir). //
-                    observe(fts, fb -> cls.get(oo).flatMap(refs::get).map(mfat::get).notNull().toSet(), oo2fbDir) //
+                    observe(ots, fb -> cls.get(oo).map(mobt::get).asSet(), oo2fbDir). //
+                    observe(fts, fb -> cls.get(oo).flatMap(refs::get).map(mfat::get).notNull().asSet(), oo2fbDir) //
             ), oo2fbDir);
             CLS.observe(mobt, cl -> create(OBT, x -> x. //
                     observe(n, ot -> n.get(cl), oo2fbDir) //
@@ -436,14 +445,14 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
         }
 
         if (fb2oo) {
-            U.observe(ooms, u -> fbms.get(u).map(moom::get).toSet(), fb2ooDir);
+            U.observe(ooms, u -> fbms.get(u).map(moom::get).asSet(), fb2ooDir);
             FBM.observe(moom, fb -> create(OOM, x -> x. //
                     observe(n, oo -> n.get(fb), fb2ooDir). //
-                    observe(cls, oo -> ots.get(fb).map(mcls::get).toSet(), fb2ooDir) //
+                    observe(cls, oo -> ots.get(fb).map(mcls::get).asSet(), fb2ooDir) //
             ), fb2ooDir);
             OBT.observe(mcls, ot -> create(CLS, x -> x. //
                     observe(n, cl -> n.get(ot), fb2ooDir). //
-                    observe(refs, cl -> _otr.get(ot).map(rlopp::get).notNull().map(mref::get).notNull().toSet(), fb2ooDir) //
+                    observe(refs, cl -> _otr.get(ot).map(rlopp::get).notNull().map(mref::get).notNull().asSet(), fb2ooDir) //
             ), fb2ooDir);
             ROL.observe(mref, rl -> otr.get(rlopp.get(rl)) != null && !"~".equals(n.get(rl)) ? create(REF, x -> x.//
                     observe(n, rf -> !"~".equals(n.get(rl)) ? n.get(rl) : n.get(rf), fb2ooDir). //
@@ -623,7 +632,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         Concurrent<Set<TestNewable>> added = run(utx, "add", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             Set<TestNewable> news = created.merge();
             Set<TestNewable> lost = news.removeAll(objects);
             assertEquals(Set.of(), lost);
@@ -748,9 +757,9 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "changeA", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             if (oo2fb && fb2oo) {
-                Set<TestNewable> noReasons = objects.filter(o -> o.dAllDerivations().isEmpty()).toSet();
+                Set<TestNewable> noReasons = objects.filter(o -> o.dAllDerivations().isEmpty()).asSet();
                 assertEquals(Set.of(), noReasons, "No Reasons");
             }
             checkLost(added.merge(), objects);
@@ -759,7 +768,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
             if (oo2fb) { // change OO
                 TestNewable oom = ooms.get(universe).get(0);
                 Set<TestNewable> classes = cls.get(oom);
-                Set<TestNewable> refferences = classes.flatMap(refs::get).toSet();
+                Set<TestNewable> refferences = classes.flatMap(refs::get).asSet();
                 TestNewable rf3 = refferences.filter(rf -> Objects.equals(n.get(rf), "r")).findAny().get();
                 TestNewable rf4 = refferences.filter(rf -> Objects.equals(n.get(rf), "s")).findAny().get();
 
@@ -780,7 +789,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "changeB", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             assertEquals((oo2fb && fb2oo) ? (FULL ? 56 : 21) : fb2oo ? (FULL ? 46 : 16) : oo2fb ? (FULL ? 42 : 16) : (FULL ? 32 : 11), objects.size());
             checkLost(added.merge(), objects);
 
@@ -797,7 +806,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "changeBackB", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             assertEquals((oo2fb && fb2oo) ? (FULL ? 56 : 21) : fb2oo ? (FULL ? 46 : 16) : oo2fb ? (FULL ? 42 : 16) : (FULL ? 32 : 11), objects.size());
             checkLost(added.merge(), objects);
 
@@ -814,7 +823,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "changeC", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             assertEquals((oo2fb && fb2oo) ? (FULL ? 56 : 21) : fb2oo ? (FULL ? 46 : 16) : oo2fb ? (FULL ? 42 : 16) : (FULL ? 32 : 11), objects.size());
             checkLost(added.merge(), objects);
 
@@ -831,7 +840,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "changeBackC", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             assertEquals((oo2fb && fb2oo) ? (FULL ? 55 : 20) : fb2oo ? (FULL ? 45 : 15) : oo2fb ? (FULL ? 42 : 16) : (FULL ? 32 : 11), objects.size());
             checkLost(added.merge(), objects);
 
@@ -850,14 +859,14 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "changeBackA", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             assertEquals((oo2fb && fb2oo) ? (FULL ? 56 : 21) : fb2oo ? (FULL ? 46 : 16) : oo2fb ? (FULL ? 42 : 16) : (FULL ? 32 : 11), objects.size());
             checkLost(added.merge(), objects);
 
             if (oo2fb) { // change OO
                 TestNewable oom = ooms.get(universe).get(0);
                 Set<TestNewable> classes = cls.get(oom);
-                Set<TestNewable> refferences = classes.flatMap(refs::get).toSet();
+                Set<TestNewable> refferences = classes.flatMap(refs::get).asSet();
                 TestNewable rf3 = refferences.filter(rf -> Objects.equals(n.get(rf), "r")).findAny().get();
                 TestNewable rf4 = refferences.filter(rf -> Objects.equals(n.get(rf), "s")).findAny().get();
 
@@ -878,7 +887,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "setType", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).filter(n -> n instanceof Universe || n.dParent() != null).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).filter(n -> n instanceof Universe || n.dParent() != null).asSet();
             assertEquals((oo2fb && fb2oo) ? (FULL ? 58 : 23) : oo2fb ? (FULL ? 45 : 19) : fb2oo ? (FULL ? 45 : 15) : (FULL ? 32 : 11), objects.size());
             checkLost(added.merge(), objects);
 
@@ -886,7 +895,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
                 TestNewable oom = ooms.get(universe).get(0);
                 Set<TestNewable> classes = cls.get(oom);
                 TestNewable cl2 = classes.filter(cl -> Objects.equals(n.get(cl), "B")).findAny().get();
-                Set<TestNewable> refferences = classes.flatMap(refs::get).toSet();
+                Set<TestNewable> refferences = classes.flatMap(refs::get).asSet();
                 TestNewable rf3 = refferences.filter(rf -> Objects.equals(n.get(rf), "r")).findAny().get();
 
                 typ.set(rf3, cl2);
@@ -912,7 +921,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "setTypeBack", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             assertEquals((oo2fb && fb2oo) ? (FULL ? 62 : 27) : oo2fb ? (FULL ? 45 : 19) : fb2oo ? (FULL ? 49 : 19) : (FULL ? 32 : 11), objects.size());
             checkLost(added.merge(), objects);
 
@@ -921,7 +930,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
                 Set<TestNewable> classes = cls.get(oom);
                 TestNewable cl1 = classes.filter(cl -> Objects.equals(n.get(cl), "A")).findAny().get();
                 TestNewable cl2 = classes.filter(cl -> Objects.equals(n.get(cl), "B")).findAny().get();
-                Set<TestNewable> refferences = classes.flatMap(refs::get).toSet();
+                Set<TestNewable> refferences = classes.flatMap(refs::get).asSet();
                 TestNewable rf3 = refferences.filter(rf -> Objects.equals(n.get(rf), "r")).findAny().get();
 
                 assertEquals(cl2, typ.get(rf3));
@@ -941,7 +950,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
 
         run(utx, "remove", c -> {
             state[0] = checkState(state[0]);
-            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = state[0].getObjects(TestNewable.class).asSet();
             assertEquals((oo2fb && fb2oo) ? (FULL ? 58 : 23) : oo2fb ? (FULL ? 45 : 19) : fb2oo ? (FULL ? 45 : 15) : (FULL ? 32 : 11), objects.size());
             checkLost(added.merge(), objects);
 
@@ -958,7 +967,7 @@ private State oofb(DclareConfig config, boolean oo2fb, boolean fb2oo, boolean oo
         }
 
         result.run(() -> {
-            Set<TestNewable> objects = result.getObjects(TestNewable.class).toSet();
+            Set<TestNewable> objects = result.getObjects(TestNewable.class).asSet();
             assertEquals(FULL ? 32 : 11, objects.size());
             checkLost(created.result(), objects);
             assertTrue(objects.allMatch(o -> o.dAllDerivations().size() >= 0 && o.dAllDerivations().size() <= 1));
@@ -1028,8 +1037,8 @@ public interface Creator {
 
     @SuppressWarnings({"rawtypes", "unchecked"})
     private static void compareStates(State as, State bs) {
-        List<Newable> al = as.getObjects(Newable.class).toList();
-        List<Newable> bl = bs.getObjects(Newable.class).toList();
+        List<Newable> al = as.getObjects(Newable.class).asList();
+        List<Newable> bl = bs.getObjects(Newable.class).asList();
         assertEquals(al.size(), bl.size());
         AtomicReference<Map<Pair<Newable, Newable>, Boolean>> done = new AtomicReference<>(Map.of());
         for (Newable an : al) {
@@ -1051,9 +1060,7 @@ private static void compareStates(State as, State bs) {
     @SuppressWarnings({"rawtypes", "unchecked", "RedundantSuppression"})
     private static boolean equals(State as, Object a, State bs, Object b, AtomicReference<Map<Pair<Newable, Newable>, Boolean>> done) {
         boolean result = false;
-        if (a instanceof Newable && b instanceof Newable) {
-            Newable an = (Newable) a;
-            Newable bn = (Newable) b;
+        if (a instanceof Newable an && b instanceof Newable bn) {
             Pair<Newable, Newable> key = Pair.of(an, bn);
             if (done.get().containsKey(key)) {
                 result = done.get().get(key);
@@ -1066,9 +1073,7 @@ private static boolean equals(State as, Object a, State bs, Object b, AtomicRefe
                 }
                 done.set(done.get().put(key, result));
             }
-        } else if (a instanceof Struct && b instanceof Struct) {
-            Struct structa = (Struct) a;
-            Struct structb = (Struct) b;
+        } else if (a instanceof Struct structa && b instanceof Struct structb) {
             if (structa.length() == structb.length()) {
                 result = true;
                 for (int i = 0; i < structa.length(); i++) {
@@ -1077,8 +1082,8 @@ private static boolean equals(State as, Object a, State bs, Object b, AtomicRefe
             }
         } else if (a instanceof Collection && b instanceof Collection) {
             if (((Collection) a).size() == ((Collection) b).size()) {
-                List al = ((Collection) a).toList();
-                List bl = ((Collection) b).toList();
+                List al = ((Collection) a).asList();
+                List bl = ((Collection) b).asList();
                 for (int ai = 0; ai < al.size(); ai++) {
                     for (int bi = 0; bi < bl.size(); bi++) {
                         if (equals(as, al.get(ai), bs, bl.get(bi), done)) {
diff --git a/src/test/java/org/modelingvalue/dclare/test/support/ModelMaker.java b/src/test/java/org/modelingvalue/dclare/test/support/ModelMaker.java
index 8a4915f2..4194d85d 100644
--- a/src/test/java/org/modelingvalue/dclare/test/support/ModelMaker.java
+++ b/src/test/java/org/modelingvalue/dclare/test/support/ModelMaker.java
@@ -15,14 +15,14 @@
 
 package org.modelingvalue.dclare.test.support;
 
-import static org.junit.jupiter.api.Assertions.assertAll;
-import static org.junit.jupiter.api.Assertions.fail;
-import static org.modelingvalue.collections.util.TraceTimer.traceLog;
-import static org.modelingvalue.dclare.SetableModifier.containment;
-
-import java.util.function.Predicate;
-
-import org.modelingvalue.collections.*;
+import org.modelingvalue.collections.Collection;
+import org.modelingvalue.collections.DefaultMap;
+import org.modelingvalue.collections.Entry;
+import org.modelingvalue.collections.List;
+import org.modelingvalue.collections.Map;
+import org.modelingvalue.collections.QualifiedDefaultSet;
+import org.modelingvalue.collections.QualifiedSet;
+import org.modelingvalue.collections.Set;
 import org.modelingvalue.collections.util.Concurrent;
 import org.modelingvalue.collections.util.ContextThread;
 import org.modelingvalue.collections.util.ContextThread.ContextPool;
@@ -36,6 +36,13 @@
 import org.modelingvalue.dclare.sync.SerializationHelper;
 import org.modelingvalue.dclare.sync.Util;
 
+import java.util.function.Predicate;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.modelingvalue.collections.util.TraceTimer.traceLog;
+import static org.modelingvalue.dclare.CoreSetableModifier.containment;
+
 @SuppressWarnings({"FieldCanBeLocal", "unchecked", "rawtypes"})
 public class ModelMaker {
     // TODO: need to fix the bug and remove this workaround:
@@ -141,7 +148,7 @@ private static TestMutable desTestObject(TestMutable mutable, TestObserved<TestM
 
     private static Set<TestMutable> desTestObjectSet(TestMutable mutable, TestObserved<TestMutable, Set<TestMutable>> obs, Object a) {
         List<String> oo = (List<String>) a;
-        return oo.map(SERIALIZATION_HELPER::deserializeMutable).toSet();
+        return oo.map(SERIALIZATION_HELPER::deserializeMutable).asSet();
     }
 
     private static String desString(TestMutable mutable, TestObserved<TestMutable, String> obs, Object a) {
@@ -154,7 +161,7 @@ private static List<String> desList(TestMutable mutable, TestObserved<TestMutabl
 
     private static Set<String> desSet(TestMutable mutable, TestObserved<TestMutable, Set<String>> obs, Object a) {
         List<String> oo = (List<String>) a;
-        return oo.toSet();
+        return oo.asSet();
     }
 
     private static Map<String, String> desMap(TestMutable mutable, TestObserved<TestMutable, Map<String, String>> obs, Object a) {
@@ -163,7 +170,7 @@ private static Map<String, String> desMap(TestMutable mutable, TestObserved<Test
 
     private static DefaultMap<String, String> desDefMap(TestMutable mutable, TestObserved<TestMutable, DefaultMap<String, String>> obs, Object a) {
         List<List<String>> oo = (List<List<String>>) a;
-        return obs.getDefault(mutable).addAll(oo.map(l -> Entry.of(l.get(0), l.get(1))).toList());
+        return obs.getDefault(mutable).addAll(oo.map(l -> Entry.of(l.get(0), l.get(1))).asList());
     }
 
     private static QualifiedSet<String, String> desQuaSet(TestMutable mutable, TestObserved<TestMutable, QualifiedSet<String, String>> obs, Object a) {
@@ -186,11 +193,11 @@ private static QualifiedDefaultSet<String, String> desQuaDefSet(TestMutable muta
                     o -> target2.set(o, source.get(o))).observe(                                                                                                                                                                     //
                             o -> extraString.set(o, "@@@@\n\"@@@" + source.get(o) + "@@@")).observe(                                                                                                                                 //
                                     o -> extra.set(o, TestMutable.of("" + source.get(o), extraClass))).observe(                                                                                                                      //
-                                            o -> extraSet.set(o, Collection.range(0, source.get(o)).flatMap(i -> Collection.of(TestMutable.of("TO-" + i, extraClass))).toSet())).observe(                                            //
+                                            o -> extraSet.set(o, Collection.range(0, source.get(o)).flatMap(i -> Collection.of(TestMutable.of("TO-" + i, extraClass))).asSet())).observe(                                            //
                                                     o -> target.set(extra.get(o), target.get(o))).observe(                                                                                                                           //
-                                                            o -> aList.set(o, Collection.range(0, source.get(o)).map(i -> "~" + i).toList())).observe(                                                                               //
-                                                                    o -> aSet.set(o, Collection.range(0, source.get(o)).flatMap(i -> Collection.of("&" + i, "@" + i * 2)).toSet())).observe(                                         //
-                                                                            o -> aMap.set(o, Collection.range(0, source.get(o)).toMap(i -> Entry.of(i + "!m!k!", i + "!m!v!")))).observe(                                            //
+                                                            o -> aList.set(o, Collection.range(0, source.get(o)).map(i -> "~" + i).asList())).observe(                                                                               //
+                                                                    o -> aSet.set(o, Collection.range(0, source.get(o)).flatMap(i -> Collection.of("&" + i, "@" + i * 2)).asSet())).observe(                                         //
+                                                                            o -> aMap.set(o, Collection.range(0, source.get(o)).asMap(i -> Entry.of(i + "!m!k!", i + "!m!v!")))).observe(                                            //
                                                                                     o -> aDefMap.set(o, aDefMap.getDefault(o).addAll(Collection.range(0, source.get(o)).map(i -> Entry.of(i + "!dm!k!", i + "!dm!v!"))))).observe(   //
                                                                                             o -> aQuaSet.set(o, aQuaSet.getDefault(o).addAll(Collection.range(0, source.get(o)).map(i -> "QS" + i)))).observe(                       //
                                                                                                     o -> aQuaDefSet.set(o, aQuaDefSet.getDefault(o).addAll(Collection.range(0, source.get(o)).map(i -> "QDS" + i))));
diff --git a/src/test/java/org/modelingvalue/dclare/test/support/TestMutableClass.java b/src/test/java/org/modelingvalue/dclare/test/support/TestMutableClass.java
index ae91f76c..b16ec491 100644
--- a/src/test/java/org/modelingvalue/dclare/test/support/TestMutableClass.java
+++ b/src/test/java/org/modelingvalue/dclare/test/support/TestMutableClass.java
@@ -55,7 +55,7 @@ public static TestMutableClass of(String id, Setable<? extends TestMutable, ?>..
     @SuppressWarnings("unchecked")
     protected TestMutableClass(Object id, Setable[] setables) {
         this.id = id;
-        this.setables = Collection.of(setables).toSet();
+        this.setables = Collection.of(setables).asSet();
         this.observers = new MutationWrapper(Set.of());
     }
 
diff --git a/src/test/java/org/modelingvalue/dclare/test/support/TestObserved.java b/src/test/java/org/modelingvalue/dclare/test/support/TestObserved.java
index f0bdb480..825874a0 100644
--- a/src/test/java/org/modelingvalue/dclare/test/support/TestObserved.java
+++ b/src/test/java/org/modelingvalue/dclare/test/support/TestObserved.java
@@ -33,15 +33,15 @@ public class TestObserved<O, T> extends Observed<O, T> {
     private final TriFunction<O, TestObserved<O, T>, Object, T> deserializeValue;
 
     @SuppressWarnings("unchecked")
-    public static <C, V> TestObserved<C, V> existing(Object id, SetableModifier... modifiers) {
+    public static <C, V> TestObserved<C, V> existing(Object id, SetableModifier<?>... modifiers) {
         return (TestObserved<C, V>) staticObservedMap.get(id);
     }
 
-    public static <C, V> Observed<C, V> of(Object id, TriFunction<C, TestObserved<C, V>, V, Object> serializeValue, TriFunction<C, TestObserved<C, V>, Object, V> deserializeValue, V def, SetableModifier... modifiers) {
+    public static <C, V> Observed<C, V> of(Object id, TriFunction<C, TestObserved<C, V>, V, Object> serializeValue, TriFunction<C, TestObserved<C, V>, Object, V> deserializeValue, V def, SetableModifier<?>... modifiers) {
         return new TestObserved<>(id, serializeValue, deserializeValue, def, null, null, null, modifiers);
     }
 
-    protected TestObserved(Object id, TriFunction<O, TestObserved<O, T>, T, Object> serializeValue, TriFunction<O, TestObserved<O, T>, Object, T> deserializeValue, T def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<O, Set<?>>> scope, QuadConsumer<LeafTransaction, O, T, T> changed, SetableModifier... modifiers) {
+    protected TestObserved(Object id, TriFunction<O, TestObserved<O, T>, T, Object> serializeValue, TriFunction<O, TestObserved<O, T>, Object, T> deserializeValue, T def, Supplier<Setable<?, ?>> opposite, Supplier<Setable<O, Set<?>>> scope, QuadConsumer<LeafTransaction, O, T, T> changed, SetableModifier<?>... modifiers) {
         super(id, o -> def, opposite, scope, changed, modifiers);
         this.serializeValue = serializeValue;
         this.deserializeValue = deserializeValue;