feat: generator facade timeout and non-existent objects

Quality of life improvements for the semantics and generator facade APIs.

17 files changed, 356 insertions, 54 deletions

diff --git a/subprojects/frontend/src/graph/GraphStore.ts b/subprojects/frontend/src/graph/GraphStore.ts
index 86ffd802..30d0a2f3 100644
--- a/subprojects/frontend/src/graph/GraphStore.ts
+++ b/subprojects/frontend/src/graph/GraphStore.ts
@@ -233,4 +233,9 @@ export default class GraphStore {
   get name(): string {
     return this.nameOverride ?? this.editorStore.simpleNameOrFallback;
   }
+
+  get showNonExistent(): boolean {
+    const existsVisibility = this.visibility.get('builtin::exists') ?? 'none';
+    return existsVisibility !== 'none' || this.scopes;
+  }
 }
diff --git a/subprojects/frontend/src/graph/GraphTheme.tsx b/subprojects/frontend/src/graph/GraphTheme.tsx
index bdc01b78..1127a46d 100644
--- a/subprojects/frontend/src/graph/GraphTheme.tsx
+++ b/subprojects/frontend/src/graph/GraphTheme.tsx
@@ -143,6 +143,21 @@ export function createGraphTheme({
     'text.label-ERROR': {
       fill: theme.palette.error.main,
     },
+    '.node-exists-FALSE': {
+      'text:not(.label-ERROR)': {
+        fill: theme.palette.text.secondary,
+      },
+      '.node-outline': {
+        stroke: theme.palette.text.secondary,
+        strokeDasharray: '2 4',
+      },
+      '.node-header': {
+        fill: theme.palette.background.default,
+      },
+      '.icon-TRUE': {
+        fill: theme.palette.text.secondary,
+      },
+    },
   };
 }
 
diff --git a/subprojects/frontend/src/graph/dotSource.ts b/subprojects/frontend/src/graph/dotSource.ts
index ce504c37..9099cd09 100644
--- a/subprojects/frontend/src/graph/dotSource.ts
+++ b/subprojects/frontend/src/graph/dotSource.ts
@@ -128,11 +128,16 @@ function createNodes(
   const {
     semantics: { nodes },
     scopes,
+    showNonExistent,
   } = graph;
 
   nodes.forEach((node, i) => {
     const data = nodeData[i];
-    if (data === undefined || data.isolated || data.exists === 'FALSE') {
+    if (
+      data === undefined ||
+      data.isolated ||
+      (!showNonExistent && data.exists === 'FALSE')
+    ) {
       return;
     }
     const classList = [
@@ -255,6 +260,7 @@ function createRelationEdges(
 ): void {
   const {
     semantics: { nodes, partialInterpretation },
+    showNonExistent,
   } = graph;
   const { detail } = relation;
 
@@ -297,9 +303,9 @@ function createRelationEdges(
     const toData = nodeData[to];
     if (
       fromData === undefined ||
-      fromData.exists === 'FALSE' ||
       toData === undefined ||
-      toData.exists === 'FALSE'
+      (!showNonExistent &&
+        (fromData.exists === 'FALSE' || toData.exists === 'FALSE'))
     ) {
       return;
     }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/CancellableCancellationToken.java b/subprojects/generator/src/main/java/tools/refinery/generator/CancellableCancellationToken.java
new file mode 100644
index 00000000..53bac196
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/CancellableCancellationToken.java
@@ -0,0 +1,38 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import tools.refinery.store.util.CancellationToken;
+
+class CancellableCancellationToken implements CancellationToken {
+        private volatile boolean cancelled;
+
+        private final CancellationToken wrappedToken;
+
+        public CancellableCancellationToken(CancellationToken wrappedToken) {
+                this.wrappedToken = wrappedToken;
+        }
+
+        public boolean isCancelled() {
+                return cancelled;
+        }
+
+        public void cancel() {
+                cancelled = true;
+        }
+
+        public void reset() {
+                cancelled = false;
+        }
+
+        @Override
+        public void checkCancelled() {
+                wrappedToken.checkCancelled();
+                if (cancelled) {
+                        throw new GeneratorTimeoutException();
+                }
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/FilteredInterpretation.java b/subprojects/generator/src/main/java/tools/refinery/generator/FilteredInterpretation.java
new file mode 100644
index 00000000..c068615f
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/FilteredInterpretation.java
@@ -0,0 +1,108 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import tools.refinery.logic.AbstractValue;
+import tools.refinery.logic.term.truthvalue.TruthValue;
+import tools.refinery.store.map.AnyVersionedMap;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Set;
+
+public class FilteredInterpretation<A extends AbstractValue<A, C>, C> implements PartialInterpretation<A, C> {
+        private final PartialInterpretation<A, C> wrappedInterpretation;
+        private final PartialInterpretation<TruthValue, Boolean> existsInterpretation;
+
+        public FilteredInterpretation(PartialInterpretation<A, C> wrappedInterpretation, PartialInterpretation<TruthValue,
+                        Boolean> existsInterpretation) {
+                this.wrappedInterpretation = wrappedInterpretation;
+                this.existsInterpretation = existsInterpretation;
+        }
+
+        @Override
+        public ReasoningAdapter getAdapter() {
+                return wrappedInterpretation.getAdapter();
+        }
+
+        @Override
+        public PartialSymbol<A, C> getPartialSymbol() {
+                return wrappedInterpretation.getPartialSymbol();
+        }
+
+        @Override
+        public Concreteness getConcreteness() {
+                return wrappedInterpretation.getConcreteness();
+        }
+
+        @Override
+        public A get(Tuple key) {
+                return tupleExists(key) ? wrappedInterpretation.get(key) :
+                wrappedInterpretation.getPartialSymbol().defaultValue();
+        }
+
+        @Override
+        public Cursor<Tuple, A> getAll() {
+                return new FilteredCursor(wrappedInterpretation.getAll());
+        }
+
+        private boolean tupleExists(Tuple key) {
+                int arity = key.getSize();
+                for (int i = 0; i < arity; i++) {
+                        if (!existsInterpretation.get(Tuple.of(key.get(i))).may()) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        private class FilteredCursor implements Cursor<Tuple, A> {
+                private final Cursor<Tuple, A> wrappedCursor;
+
+                private FilteredCursor(Cursor<Tuple, A> wrappedCursor) {
+                        this.wrappedCursor = wrappedCursor;
+                }
+
+                @Override
+                public Tuple getKey() {
+                        return wrappedCursor.getKey();
+                }
+
+                @Override
+                public A getValue() {
+                        return wrappedCursor.getValue();
+                }
+
+                @Override
+                public boolean isTerminated() {
+                        return wrappedCursor.isTerminated();
+                }
+
+                @Override
+                public boolean move() {
+                        while (wrappedCursor.move()) {
+                                if (tupleExists(getKey())) {
+                                        return true;
+                                }
+                        }
+                        return false;
+                }
+
+                @Override
+                public boolean isDirty() {
+                        return wrappedCursor.isDirty();
+                }
+
+                @Override
+                public Set<AnyVersionedMap> getDependingMaps() {
+                        return wrappedCursor.getDependingMaps();
+                }
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/GeneratorResult.java b/subprojects/generator/src/main/java/tools/refinery/generator/GeneratorResult.java
new file mode 100644
index 00000000..3ce2631a
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/GeneratorResult.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+public enum GeneratorResult {
+        SUCCESS {
+                @Override
+                public void orThrow() {
+                        // No need to throw on error.
+                }
+        },
+        UNSATISFIABLE {
+                @Override
+                public void orThrow() {
+                        throw new UnsatisfiableProblemException();
+                }
+        },
+        TIMEOUT {
+                @Override
+                public void orThrow() {
+                        throw new GeneratorTimeoutException();
+                }
+        };
+
+        public abstract void orThrow();
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/GeneratorTimeoutException.java b/subprojects/generator/src/main/java/tools/refinery/generator/GeneratorTimeoutException.java
new file mode 100644
index 00000000..4312a324
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/GeneratorTimeoutException.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+public class GeneratorTimeoutException extends RuntimeException {
+        public GeneratorTimeoutException() {
+                super("Model generation timed out");
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacadeFactory.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacadeFactory.java
new file mode 100644
index 00000000..75ca5082
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacadeFactory.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import tools.refinery.language.semantics.ModelInitializer;
+import tools.refinery.store.util.CancellationToken;
+
+public abstract sealed class ModelFacadeFactory<T extends ModelFacadeFactory<T>> permits ModelSemanticsFactory,
+                ModelGeneratorFactory {
+        @Inject
+        private Provider<ModelInitializer> initializerProvider;
+
+        private CancellationToken cancellationToken = CancellationToken.NONE;
+
+        private boolean keepNonExistingObjects = false;
+
+        protected abstract T getSelf();
+
+        public T cancellationToken(CancellationToken cancellationToken) {
+                this.cancellationToken = cancellationToken;
+                return getSelf();
+        }
+
+        public T keepNonExistingObjects(boolean removeNonExistentObjects) {
+                this.keepNonExistingObjects = removeNonExistentObjects;
+                return getSelf();
+        }
+
+        protected ModelInitializer createModelInitializer() {
+                return initializerProvider.get();
+        }
+
+        protected CancellationToken getCancellationToken() {
+                return cancellationToken;
+        }
+
+        protected boolean isKeepNonExistingObjects() {
+                return keepNonExistingObjects;
+        }
+
+        protected void checkCancelled() {
+                cancellationToken.checkCancelled();
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
index 8dff5622..2f459eb9 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
@@ -10,26 +10,38 @@ import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.semantics.ProblemTrace;
 import tools.refinery.language.semantics.SolutionSerializer;
 import tools.refinery.logic.AbstractValue;
+import tools.refinery.logic.term.truthvalue.TruthValue;
 import tools.refinery.store.dse.strategy.BestFirstStoreManager;
 import tools.refinery.store.dse.transition.statespace.SolutionStore;
 import tools.refinery.store.map.Version;
 import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
 import tools.refinery.store.reasoning.seed.ModelSeed;
 
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
 public class ModelGenerator extends ModelFacade {
         private final Version initialVersion;
         private final Provider<SolutionSerializer> solutionSerializerProvider;
+        private final CancellableCancellationToken cancellationToken;
+        private final boolean keepNonExistingObjects;
+        private final PartialInterpretation<TruthValue, Boolean> existsInterpretation;
         private long randomSeed = 1;
         private int maxNumberOfSolutions = 1;
         private SolutionStore solutionStore;
 
         ModelGenerator(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed,
-                                   Provider<SolutionSerializer> solutionSerializerProvider) {
+                                   Provider<SolutionSerializer> solutionSerializerProvider,
+                                   CancellableCancellationToken cancellationToken, boolean keepNonExistingObjects) {
                 super(problemTrace, store, modelSeed, Concreteness.CANDIDATE);
                 this.solutionSerializerProvider = solutionSerializerProvider;
+                this.cancellationToken = cancellationToken;
+                this.keepNonExistingObjects = keepNonExistingObjects;
+                existsInterpretation = super.getPartialInterpretation(ReasoningAdapter.EXISTS_SYMBOL);
                 initialVersion = getModel().commit();
         }
 
@@ -71,33 +83,52 @@ public class ModelGenerator extends ModelFacade {
                 return solutionStore != null;
         }
 
-        // This method only makes sense if it returns {@code true} on success.
-        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
-        public boolean tryGenerate() {
+        public GeneratorResult tryGenerate() {
+                if (cancellationToken.isCancelled()) {
+                        throw new IllegalStateException("Model generation was previously cancelled");
+                }
                 solutionStore = null;
                 randomSeed++;
                 var bestFirst = new BestFirstStoreManager(getModelStore(), maxNumberOfSolutions);
                 bestFirst.startExploration(initialVersion, randomSeed);
                 var solutions = bestFirst.getSolutionStore().getSolutions();
                 if (solutions.isEmpty()) {
-                        return false;
+                        return GeneratorResult.UNSATISFIABLE;
                 }
                 getModel().restore(solutions.getFirst().version());
                 solutionStore = bestFirst.getSolutionStore();
-                return true;
+                return GeneratorResult.SUCCESS;
         }
 
         public void generate() {
-                if (!tryGenerate()) {
-                        throw new UnsatisfiableProblemException();
+                tryGenerate().orThrow();
+        }
+
+        public GeneratorResult tryGenerateWithTimeout(long l, TimeUnit timeUnit) {
+                try (var executorService = Executors.newSingleThreadScheduledExecutor()) {
+                        var timeoutFuture = executorService.schedule(cancellationToken::cancel, l, timeUnit);
+                        try {
+                                return tryGenerate();
+                        } catch (GeneratorTimeoutException e) {
+                                return GeneratorResult.TIMEOUT;
+                        } finally {
+                                timeoutFuture.cancel(true);
+                                cancellationToken.reset();
+                        }
                 }
         }
 
+        public void generateWithTimeout(long l, TimeUnit timeUnit) {
+                tryGenerateWithTimeout(l, timeUnit).orThrow();
+        }
+
         @Override
         public <A extends AbstractValue<A, C>, C> PartialInterpretation<A, C> getPartialInterpretation(
                         PartialSymbol<A, C> partialSymbol) {
                 checkSuccessfulGeneration();
-                return super.getPartialInterpretation(partialSymbol);
+                var partialInterpretation = super.getPartialInterpretation(partialSymbol);
+                return keepNonExistingObjects ? partialInterpretation :
+                                new FilteredInterpretation<>(partialInterpretation, existsInterpretation);
         }
 
         public Problem serializeSolution() {
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
index 0a1b4396..b041c8f6 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
@@ -8,7 +8,6 @@ package tools.refinery.generator;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
 import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.semantics.ModelInitializer;
 import tools.refinery.language.semantics.SolutionSerializer;
 import tools.refinery.store.dse.propagation.PropagationAdapter;
 import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
@@ -20,30 +19,24 @@ import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.statecoding.StateCodeCalculatorFactory;
 import tools.refinery.store.statecoding.StateCoderAdapter;
 import tools.refinery.store.statecoding.neighborhood.NeighborhoodCalculator;
-import tools.refinery.store.util.CancellationToken;
 
 import java.util.Collection;
 import java.util.Set;
 
 // This class is used as a fluent builder, so it's not necessary to use the return value of all of its methods.
 @SuppressWarnings("UnusedReturnValue")
-public final class ModelGeneratorFactory {
-        @Inject
-        private Provider<ModelInitializer> initializerProvider;
-
+public final class ModelGeneratorFactory extends ModelFacadeFactory<ModelGeneratorFactory> {
         @Inject
         private Provider<SolutionSerializer> solutionSerializerProvider;
 
-        private CancellationToken cancellationToken = CancellationToken.NONE;
-
         private boolean debugPartialInterpretations;
 
         private boolean partialInterpretationBasedNeighborhoods;
 
         private int stateCoderDepth = NeighborhoodCalculator.DEFAULT_DEPTH;
 
-        public ModelGeneratorFactory cancellationToken(CancellationToken cancellationToken) {
-                this.cancellationToken = cancellationToken;
+        @Override
+        protected ModelGeneratorFactory getSelf() {
                 return this;
         }
 
@@ -64,22 +57,23 @@ public final class ModelGeneratorFactory {
         }
 
         public ModelGenerator createGenerator(Problem problem) {
-                var initializer = initializerProvider.get();
+                var initializer = createModelInitializer();
                 initializer.readProblem(problem);
-                cancellationToken.checkCancelled();
+                checkCancelled();
+                var cancellationToken = new CancellableCancellationToken(getCancellationToken());
                 var storeBuilder = ModelStore.builder()
                                 .cancellationToken(cancellationToken)
                                 .with(QueryInterpreterAdapter.builder())
                                 .with(PropagationAdapter.builder())
                                 .with(StateCoderAdapter.builder()
-                                                .stateCodeCalculatorFactory(getStateCoderCalculatorFactory()))
+                                                .stateCodeCalculatorFactory(getStateCodeCalculatorFactory()))
                                 .with(DesignSpaceExplorationAdapter.builder())
                                 .with(ReasoningAdapter.builder()
                                                 .requiredInterpretations(getRequiredInterpretations()));
-                initializer.configureStoreBuilder(storeBuilder);
+                initializer.configureStoreBuilder(storeBuilder, isKeepNonExistingObjects());
                 var store = storeBuilder.build();
                 var generator = new ModelGenerator(initializer.getProblemTrace(), store, initializer.getModelSeed(),
-                                solutionSerializerProvider);
+                                solutionSerializerProvider, cancellationToken, isKeepNonExistingObjects());
                 generator.getPropagationResult().throwIfRejected();
                 return generator;
         }
@@ -90,7 +84,7 @@ public final class ModelGeneratorFactory {
                                 Set.of(Concreteness.CANDIDATE);
         }
 
-        private StateCodeCalculatorFactory getStateCoderCalculatorFactory() {
+        private StateCodeCalculatorFactory getStateCodeCalculatorFactory() {
                 return partialInterpretationBasedNeighborhoods ?
                                 PartialNeighborhoodCalculator.factory(Concreteness.PARTIAL, stateCoderDepth) :
                                 NeighborhoodCalculator.factory(stateCoderDepth);
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
index 3c3488df..43427502 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
@@ -5,27 +5,18 @@
  */
 package tools.refinery.generator;
 
-import com.google.inject.Inject;
-import com.google.inject.Provider;
 import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.semantics.ModelInitializer;
 import tools.refinery.store.dse.propagation.PropagationAdapter;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.literal.Concreteness;
-import tools.refinery.store.util.CancellationToken;
 
 import java.util.Set;
 
-public final class ModelSemanticsFactory {
-        @Inject
-        private Provider<ModelInitializer> initializerProvider;
-
-        private CancellationToken cancellationToken = CancellationToken.NONE;
-
-        public ModelSemanticsFactory cancellationToken(CancellationToken cancellationToken) {
-                this.cancellationToken = cancellationToken;
+public final class ModelSemanticsFactory extends ModelFacadeFactory<ModelSemanticsFactory> {
+        @Override
+        protected ModelSemanticsFactory getSelf() {
                 return this;
         }
 
@@ -36,16 +27,17 @@ public final class ModelSemanticsFactory {
         }
 
         public ModelSemantics tryCreateSemantics(Problem problem) {
-                var initializer = initializerProvider.get();
+                var initializer = createModelInitializer();
                 initializer.readProblem(problem);
+                checkCancelled();
                 var storeBuilder = ModelStore.builder()
-                                .cancellationToken(cancellationToken)
+                                .cancellationToken(getCancellationToken())
                                 .with(QueryInterpreterAdapter.builder())
                                 .with(PropagationAdapter.builder()
                                                 .throwOnFatalRejection(false))
                                 .with(ReasoningAdapter.builder()
                                                 .requiredInterpretations(Set.of(Concreteness.PARTIAL)));
-                initializer.configureStoreBuilder(storeBuilder);
+                initializer.configureStoreBuilder(storeBuilder, isKeepNonExistingObjects());
                 var store = storeBuilder.build();
                 return new ModelSemantics(initializer.getProblemTrace(), store, initializer.getModelSeed());
         }
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
index d71cf35f..6aea3132 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
@@ -180,9 +180,13 @@ public class ModelInitializer {
         }
 
         public void configureStoreBuilder(ModelStoreBuilder storeBuilder) {
+                configureStoreBuilder(storeBuilder, false);
+        }
+
+        public void configureStoreBuilder(ModelStoreBuilder storeBuilder, boolean keepNonExistingObjects) {
                 checkProblem();
                 try {
-                        storeBuilder.with(new MultiObjectTranslator());
+                        storeBuilder.with(new MultiObjectTranslator(keepNonExistingObjects));
                         storeBuilder.with(new MetamodelTranslator(metamodel));
                         if (scopePropagator != null) {
                                 if (storeBuilder.tryGetAdapter(PropagationBuilder.class).isEmpty()) {
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
index 7febce7d..e7facbf7 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
@@ -9,11 +9,8 @@ import com.google.inject.Inject;
 import org.eclipse.xtext.service.OperationCanceledManager;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import tools.refinery.generator.ModelGenerator;
-import tools.refinery.generator.ModelGeneratorFactory;
+import tools.refinery.generator.*;
 import tools.refinery.language.web.semantics.metadata.MetadataCreator;
-import tools.refinery.generator.ProblemLoader;
-import tools.refinery.generator.ValidationErrorsException;
 import tools.refinery.language.web.semantics.PartialInterpretation2Json;
 import tools.refinery.language.web.xtext.server.ThreadPoolExecutorServiceProvider;
 import tools.refinery.language.web.xtext.server.push.PushWebDocument;
@@ -149,7 +146,7 @@ public class ModelGenerationWorker implements Runnable {
                 }
                 notifyResult(new ModelGenerationStatusResult(uuid, "Generating model"));
                 generator.setRandomSeed(randomSeed);
-                if (!generator.tryGenerate()) {
+                if (generator.tryGenerate() != GeneratorResult.SUCCESS) {
                         return new ModelGenerationErrorResult(uuid, "Problem is unsatisfiable");
                 }
                 notifyResult(new ModelGenerationStatusResult(uuid, "Saving generated model"));
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
index a96b68f9..508e716e 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
@@ -72,7 +72,10 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                 cancellationToken.checkCancelled();
                 ModelSemantics semantics;
                 try {
-                        semantics = semanticsFactory.cancellationToken(cancellationToken).tryCreateSemantics(problem);
+                        semantics = semanticsFactory
+                                        .cancellationToken(cancellationToken)
+                                        .keepNonExistingObjects(true)
+                                        .tryCreateSemantics(problem);
                 } catch (TranslationException e) {
                         return new SemanticsResult(e.getMessage());
                 } catch (TracedException e) {
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
index 386ae1d8..b83d162e 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
@@ -204,6 +204,8 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 if (nodeToDelete == currentModelSize - 1) {
                         nodeCountInterpretation.put(Tuple.of(), nodeToDelete);
                 }
+                // We mustn't reuse the ID of {@code nodeToDelete} in any circumstance, because clients may depend on stable
+                // node IDs for nodes in the initial partial model.
                 return true;
         }
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/CleanupPropagator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/CleanupPropagator.java
index f14b4783..6feccae3 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/CleanupPropagator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/CleanupPropagator.java
@@ -11,6 +11,7 @@ import tools.refinery.logic.term.uppercardinality.UpperCardinalities;
 import tools.refinery.logic.term.uppercardinality.UpperCardinality;
 import tools.refinery.logic.term.uppercardinality.UpperCardinalityTerms;
 import tools.refinery.store.dse.propagation.BoundPropagator;
+import tools.refinery.store.dse.propagation.PropagationRejectedResult;
 import tools.refinery.store.dse.propagation.PropagationResult;
 import tools.refinery.store.dse.propagation.Propagator;
 import tools.refinery.store.model.Model;
@@ -48,7 +49,7 @@ public class CleanupPropagator implements Propagator {
                 return new BoundCleanupPropagator(model);
         }
 
-        private static class BoundCleanupPropagator implements BoundPropagator {
+        private class BoundCleanupPropagator implements BoundPropagator {
                 private final Model model;
                 private final ModelQueryAdapter queryEngine;
                 private final ResultSet<Boolean> resultSet;
@@ -70,7 +71,11 @@ public class CleanupPropagator implements Propagator {
                         var cursor = resultSet.getAll();
                         while (cursor.move()) {
                                 propagated = true;
-                                reasoningAdapter.cleanup(cursor.getKey().get(0));
+                                var nodeToDelete = cursor.getKey().get(0);
+                                if (!reasoningAdapter.cleanup(nodeToDelete)) {
+                                        return new PropagationRejectedResult(CleanupPropagator.this,
+                            "Failed to remove node: " + nodeToDelete, true);
+                                }
                         }
                         return propagated ? PropagationResult.PROPAGATED : PropagationResult.UNCHANGED;
                 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java
index 05d96689..7b3be76d 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java
@@ -41,6 +41,16 @@ public class MultiObjectTranslator implements ModelStoreConfiguration {
         public static final PartialFunction<CardinalityInterval, Integer> COUNT_SYMBOL = new PartialFunction<>("COUNT", 1,
                         CardinalityDomain.INSTANCE);
 
+        private final boolean keepNonExistingObjects;
+
+        public MultiObjectTranslator(boolean keepNonExistingObjects) {
+                this.keepNonExistingObjects = keepNonExistingObjects;
+        }
+
+        public MultiObjectTranslator() {
+                this(true);
+        }
+
         @Override
         public void apply(ModelStoreBuilder storeBuilder) {
                 storeBuilder.symbol(COUNT_STORAGE);
@@ -90,7 +100,9 @@ public class MultiObjectTranslator implements ModelStoreConfiguration {
                 reasoningBuilder.initializer(new MultiObjectInitializer(COUNT_STORAGE));
                 reasoningBuilder.storageRefiner(COUNT_STORAGE, MultiObjectStorageRefiner::new);
 
-                storeBuilder.tryGetAdapter(PropagationBuilder.class)
-                                .ifPresent(propagationBuilder -> propagationBuilder.propagator(new CleanupPropagator()));
+                if (!keepNonExistingObjects) {
+                        storeBuilder.tryGetAdapter(PropagationBuilder.class)
+                                        .ifPresent(propagationBuilder -> propagationBuilder.propagator(new CleanupPropagator()));
+                }
         }
 }