17 files changed, 135 insertions, 78 deletions

diff --git a/subprojects/frontend/src/editor/EditorStore.ts b/subprojects/frontend/src/editor/EditorStore.ts
index d0b580ed..c5dd5728 100644
--- a/subprojects/frontend/src/editor/EditorStore.ts
+++ b/subprojects/frontend/src/editor/EditorStore.ts
@@ -36,7 +36,7 @@ import {
 } from '../utils/fileIO';
 import getLogger from '../utils/getLogger';
 import type XtextClient from '../xtext/XtextClient';
-import type { SemanticsSuccessResult } from '../xtext/xtextServiceResults';
+import type { SemanticsModelResult } from '../xtext/xtextServiceResults';
 
 import EditorErrors from './EditorErrors';
 import GeneratedModelStore from './GeneratedModelStore';
@@ -365,12 +365,11 @@ export default class EditorStore {
     }
   }
 
-  setSemanticsError(semanticsError: string) {
+  setSemanticsError(semanticsError: string | undefined) {
     this.semanticsError = semanticsError;
   }
 
-  setSemantics(semantics: SemanticsSuccessResult) {
-    this.semanticsError = undefined;
+  setSemantics(semantics: SemanticsModelResult) {
     this.graph.setSemantics(semantics);
   }
 
@@ -447,7 +446,7 @@ export default class EditorStore {
 
   setGeneratedModelSemantics(
     uuid: string,
-    semantics: SemanticsSuccessResult,
+    semantics: SemanticsModelResult,
   ): void {
     this.generatedModels.get(uuid)?.setSemantics(semantics);
   }
diff --git a/subprojects/frontend/src/editor/GeneratedModelStore.ts b/subprojects/frontend/src/editor/GeneratedModelStore.ts
index 4af49e2c..fb9efbcf 100644
--- a/subprojects/frontend/src/editor/GeneratedModelStore.ts
+++ b/subprojects/frontend/src/editor/GeneratedModelStore.ts
@@ -7,7 +7,7 @@
 import { makeAutoObservable } from 'mobx';
 
 import GraphStore from '../graph/GraphStore';
-import type { SemanticsSuccessResult } from '../xtext/xtextServiceResults';
+import type { SemanticsModelResult } from '../xtext/xtextServiceResults';
 
 import type EditorStore from './EditorStore';
 
@@ -48,7 +48,7 @@ export default class GeneratedModelStore {
     }
   }
 
-  setSemantics(semantics: SemanticsSuccessResult): void {
+  setSemantics(semantics: SemanticsModelResult): void {
     if (this.running) {
       const name = `${this.editorStore.simpleNameOrFallback}_solution_${this.randomSeed}`;
       this.graph = new GraphStore(this.editorStore, name);
diff --git a/subprojects/frontend/src/graph/GraphStore.ts b/subprojects/frontend/src/graph/GraphStore.ts
index 301b4d86..86ffd802 100644
--- a/subprojects/frontend/src/graph/GraphStore.ts
+++ b/subprojects/frontend/src/graph/GraphStore.ts
@@ -9,7 +9,7 @@ import { makeAutoObservable, observable } from 'mobx';
 import type EditorStore from '../editor/EditorStore';
 import type {
   RelationMetadata,
-  SemanticsSuccessResult,
+  SemanticsModelResult,
 } from '../xtext/xtextServiceResults';
 
 export type Visibility = 'all' | 'must' | 'none';
@@ -52,7 +52,7 @@ export function isVisibilityAllowed(
 const TYPE_HASH_HEX_PREFFIX = '_';
 
 export default class GraphStore {
-  semantics: SemanticsSuccessResult = {
+  semantics: SemanticsModelResult = {
     nodes: [],
     relations: [],
     partialInterpretation: {},
@@ -175,7 +175,7 @@ export default class GraphStore {
     }
   }
 
-  setSemantics(semantics: SemanticsSuccessResult) {
+  setSemantics(semantics: SemanticsModelResult) {
     this.semantics = semantics;
     this.relationMetadata.clear();
     this.semantics.relations.forEach((metadata) => {
diff --git a/subprojects/frontend/src/xtext/SemanticsService.ts b/subprojects/frontend/src/xtext/SemanticsService.ts
index d68b87a9..b6692f2b 100644
--- a/subprojects/frontend/src/xtext/SemanticsService.ts
+++ b/subprojects/frontend/src/xtext/SemanticsService.ts
@@ -1,9 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 
+import { runInAction } from 'mobx';
+
 import type EditorStore from '../editor/EditorStore';
 
 import type ValidationService from './ValidationService';
@@ -17,16 +19,21 @@ export default class SemanticsService {
 
   onPush(push: unknown): void {
     const result = SemanticsResult.parse(push);
-    if ('issues' in result) {
-      this.validationService.setSemanticsIssues(result.issues);
-    } else {
-      this.validationService.setSemanticsIssues([]);
+    runInAction(() => {
+      if ('issues' in result && result.issues !== undefined) {
+        this.validationService.setSemanticsIssues(result.issues);
+      } else {
+        this.validationService.setSemanticsIssues([]);
+      }
       if ('error' in result) {
         this.store.setSemanticsError(result.error);
       } else {
-        this.store.setSemantics(result);
+        this.store.setSemanticsError(undefined);
+      }
+      if ('model' in result && result.model !== undefined) {
+        this.store.setSemantics(result.model);
       }
-    }
-    this.store.analysisCompleted();
+      this.store.analysisCompleted();
+    });
   }
 }
diff --git a/subprojects/frontend/src/xtext/xtextServiceResults.ts b/subprojects/frontend/src/xtext/xtextServiceResults.ts
index 792c7de3..c5bc1320 100644
--- a/subprojects/frontend/src/xtext/xtextServiceResults.ts
+++ b/subprojects/frontend/src/xtext/xtextServiceResults.ts
@@ -162,7 +162,7 @@ export const RelationMetadata = z.object({
 
 export type RelationMetadata = z.infer<typeof RelationMetadata>;
 
-export const SemanticsSuccessResult = z.object({
+export const SemanticsModelResult = z.object({
   nodes: NodeMetadata.array(),
   relations: RelationMetadata.array(),
   partialInterpretation: z.record(
@@ -171,13 +171,13 @@ export const SemanticsSuccessResult = z.object({
   ),
 });
 
-export type SemanticsSuccessResult = z.infer<typeof SemanticsSuccessResult>;
+export type SemanticsModelResult = z.infer<typeof SemanticsModelResult>;
 
-export const SemanticsResult = z.union([
-  z.object({ error: z.string() }),
-  z.object({ issues: Issue.array() }),
-  SemanticsSuccessResult,
-]);
+export const SemanticsResult = z.object({
+  model: SemanticsModelResult.optional(),
+  error: z.string().min(1).optional(),
+  issues: Issue.array().optional(),
+});
 
 export type SemanticsResult = z.infer<typeof SemanticsResult>;
 
@@ -190,7 +190,7 @@ export const ModelGenerationResult = z.union([
     uuid: z.string().min(1),
     error: z.string(),
   }),
-  SemanticsSuccessResult.extend({
+  SemanticsModelResult.extend({
     uuid: z.string().min(1),
   }),
 ]);
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacade.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacade.java
index eaf60082..459503cd 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacade.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacade.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -15,11 +15,13 @@ 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 tools.refinery.store.reasoning.seed.PropagatedModel;
 import tools.refinery.store.reasoning.translator.TranslationException;
 
 public abstract class ModelFacade {
         private final ProblemTrace problemTrace;
         private final ModelStore store;
+        private final PropagatedModel propagatedModel;
         private final Model model;
         private final ReasoningAdapter reasoningAdapter;
         private final Concreteness concreteness;
@@ -29,10 +31,11 @@ public abstract class ModelFacade {
                 this.problemTrace = problemTrace;
                 this.store = store;
                 try {
-                        model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                        propagatedModel = store.getAdapter(ReasoningStoreAdapter.class).tryCreateInitialModel(modelSeed);
                 } catch (TranslationException e) {
                         throw problemTrace.wrapException(e);
                 }
+                model = propagatedModel.model();
                 reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
                 this.concreteness = concreteness;
         }
@@ -49,6 +52,14 @@ public abstract class ModelFacade {
                 return model;
         }
 
+        public boolean isRejected() {
+                return propagatedModel.isRejected();
+        }
+
+        public void throwIfRejected() {
+                propagatedModel.throwIfRejected();
+        }
+
         public Concreteness getConcreteness() {
                 return concreteness;
         }
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 3bdc1266..1b222204 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -78,8 +78,10 @@ public final class ModelGeneratorFactory {
                                                 .requiredInterpretations(getRequiredInterpretations()));
                 initializer.configureStoreBuilder(storeBuilder);
                 var store = storeBuilder.build();
-                return new ModelGenerator(initializer.getProblemTrace(), store, initializer.getModelSeed(),
+                var generator = new ModelGenerator(initializer.getProblemTrace(), store, initializer.getModelSeed(),
                                 solutionSerializerProvider);
+                generator.throwIfRejected();
+                return generator;
         }
 
         private Collection<Concreteness> getRequiredInterpretations() {
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 b6263b37..20f404f3 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
@@ -30,6 +30,12 @@ public final class ModelSemanticsFactory {
         }
 
         public ModelSemantics createSemantics(Problem problem) {
+                var semantics = tryCreateSemantics(problem);
+                semantics.throwIfRejected();
+                return semantics;
+        }
+
+        public ModelSemantics tryCreateSemantics(Problem problem) {
                 var initializer = initializerProvider.get();
                 initializer.readProblem(problem);
                 var storeBuilder = ModelStore.builder()
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsInternalErrorResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsInternalErrorResult.java
deleted file mode 100644
index ff592e93..00000000
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsInternalErrorResult.java
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.language.web.semantics;
-
-public record SemanticsInternalErrorResult(String error) implements SemanticsResult {
-}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsIssuesResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsIssuesResult.java
deleted file mode 100644
index 644bd179..00000000
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsIssuesResult.java
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.language.web.semantics;
-
-import org.eclipse.xtext.web.server.validation.ValidationResult;
-
-import java.util.List;
-
-public record SemanticsIssuesResult(List<ValidationResult.Issue> issues) implements SemanticsResult {
-}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsSuccessResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsModelResult.java
index f26fa2b2..b0ec58c3 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsSuccessResult.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsModelResult.java
@@ -11,6 +11,7 @@ import tools.refinery.language.web.semantics.metadata.RelationMetadata;
 
 import java.util.List;
 
-public record SemanticsSuccessResult(List<NodeMetadata> nodes, List<RelationMetadata> relations,
-                                                                         JsonObject partialInterpretation) implements SemanticsResult {
+public record SemanticsModelResult(List<NodeMetadata> nodes, List<RelationMetadata> relations,
+                                                                   JsonObject partialInterpretation) {
+        public static SemanticsModelResult EMPTY = new SemanticsModelResult(List.of(), List.of(), new JsonObject());
 }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsResult.java
index a2e19a2f..16f25309 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsResult.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsResult.java
@@ -6,7 +6,25 @@
 package tools.refinery.language.web.semantics;
 
 import org.eclipse.xtext.web.server.IServiceResult;
+import org.eclipse.xtext.web.server.validation.ValidationResult;
 
-public sealed interface SemanticsResult extends IServiceResult permits SemanticsSuccessResult,
-                SemanticsInternalErrorResult, SemanticsIssuesResult {
+import java.util.List;
+
+public record SemanticsResult(SemanticsModelResult model, String error,
+                                                          List<ValidationResult.Issue> issues) implements IServiceResult {
+        public SemanticsResult(SemanticsModelResult model) {
+                this(model, null, List.of());
+        }
+
+        public SemanticsResult(String error) {
+                this(null, error, List.of());
+        }
+
+        public SemanticsResult(SemanticsModelResult model, String error) {
+                this(model, error, List.of());
+        }
+
+        public SemanticsResult(List<ValidationResult.Issue> issues) {
+                this(null, null, issues);
+        }
 }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
index 331ef84b..f6b723fe 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
@@ -5,7 +5,6 @@
  */
 package tools.refinery.language.web.semantics;
 
-import com.google.gson.JsonObject;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
 import com.google.inject.Singleton;
@@ -21,9 +20,11 @@ import org.slf4j.LoggerFactory;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.web.xtext.server.push.PushWebDocument;
 
-import java.util.List;
 import java.util.Optional;
-import java.util.concurrent.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 @Singleton
@@ -74,7 +75,7 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                 }
                 var problem = getProblem(doc);
                 if (problem == null) {
-                        return new SemanticsSuccessResult(List.of(), List.of(), new JsonObject());
+                        return new SemanticsResult(SemanticsModelResult.EMPTY);
                 }
                 var worker = workerProvider.get();
                 worker.setProblem(problem, cancelIndicator);
@@ -101,14 +102,14 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                         if (message == null) {
                                 message = "Partial interpretation error";
                         }
-                        return new SemanticsInternalErrorResult(message);
+                        return new SemanticsResult(message);
                 } catch (TimeoutException e) {
                         future.cancel(true);
                         if (!warmedUpCurrently) {
                                 warmedUp.set(true);
                         }
                         LOG.trace("Semantics service timeout", e);
-                        return new SemanticsInternalErrorResult("Partial interpretation timed out");
+                        return new SemanticsResult("Partial interpretation timed out");
                 }
                 if (LOG.isTraceEnabled()) {
                         long end = System.currentTimeMillis();
@@ -133,7 +134,7 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                 if (contents.isEmpty()) {
                         return null;
                 }
-                var model = contents.get(0);
+                var model = contents.getFirst();
                 if (!(model instanceof Problem problem)) {
                         return null;
                 }
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 fed3c8a3..32791960 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
@@ -21,6 +21,7 @@ import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.web.semantics.metadata.MetadataCreator;
 import tools.refinery.language.semantics.TracedException;
 import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.seed.PropagatedModel;
 import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.util.CancellationToken;
 
@@ -63,9 +64,9 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                 cancellationToken.checkCancelled();
                 ModelSemantics semantics;
                 try {
-                        semantics = semanticsFactory.cancellationToken(cancellationToken).createSemantics(problem);
+                        semantics = semanticsFactory.cancellationToken(cancellationToken).tryCreateSemantics(problem);
                 } catch (TranslationException e) {
-                        return new SemanticsInternalErrorResult(e.getMessage());
+                        return new SemanticsResult(e.getMessage());
                 } catch (TracedException e) {
                         var cause = e.getCause();
                         // Suppress the type of the cause exception.
@@ -79,12 +80,14 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                 var relationsMetadata = metadataCreator.getRelationsMetadata();
                 cancellationToken.checkCancelled();
                 var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(semantics, cancellationToken);
-                return new SemanticsSuccessResult(nodesMetadata, relationsMetadata, partialInterpretation);
+                var modelResult = new SemanticsModelResult(nodesMetadata, relationsMetadata, partialInterpretation);
+                var error = semantics.isRejected() ? PropagatedModel.PROPAGATION_FAILED_MESSAGE : null;
+                return new SemanticsResult(modelResult, error);
         }
 
         private SemanticsResult getTracedErrorResult(EObject sourceElement, String message) {
                 if (sourceElement == null || !problem.eResource().equals(sourceElement.eResource())) {
-                        return new SemanticsInternalErrorResult(message);
+                        return new SemanticsResult(message);
                 }
                 var diagnostic = new FeatureBasedDiagnostic(Diagnostic.ERROR, message, sourceElement, null, 0,
                                 CheckType.EXPENSIVE, DIAGNOSTIC_ID);
@@ -94,6 +97,6 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                                 .map(issue -> new ValidationResult.Issue(issue.getMessage(), "error", issue.getLineNumber(),
                                                 issue.getColumn(), issue.getOffset(), issue.getLength()))
                                 .toList();
-                return new SemanticsIssuesResult(issues);
+                return new SemanticsResult(issues);
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
index fe3cc3ea..98883dcf 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -10,6 +10,7 @@ import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.seed.PropagatedModel;
 
 import java.util.Collection;
 import java.util.Set;
@@ -21,7 +22,13 @@ public interface ReasoningStoreAdapter extends ModelStoreAdapter {
 
         Set<Concreteness> getSupportedInterpretations();
 
-        Model createInitialModel(ModelSeed modelSeed);
+        default Model createInitialModel(ModelSeed modelSeed) {
+                var result = tryCreateInitialModel(modelSeed);
+                result.throwIfRejected();
+                return result.model();
+        }
+
+        PropagatedModel tryCreateInitialModel(ModelSeed modelSeed);
 
         @Override
         ReasoningAdapter createModelAdapter(Model model);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
index 9ef6fb16..df4b6457 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
@@ -1,11 +1,12 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.internal;
 
 import tools.refinery.store.dse.propagation.PropagationAdapter;
+import tools.refinery.store.dse.propagation.PropagationResult;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
@@ -17,6 +18,7 @@ import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
 import tools.refinery.store.reasoning.refinement.StorageRefiner;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.seed.PropagatedModel;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
@@ -98,19 +100,18 @@ class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
                 return factory.create(typedSymbol, model);
         }
 
-        public Model createInitialModel(ModelSeed modelSeed) {
+        @Override
+        public PropagatedModel tryCreateInitialModel(ModelSeed modelSeed) {
                 var model = store.createEmptyModel();
                 model.getInterpretation(ReasoningAdapterImpl.NODE_COUNT_SYMBOL).put(Tuple.of(), modelSeed.getNodeCount());
                 for (var initializer : initializers) {
                         initializer.initialize(model, modelSeed);
                 }
-                model.tryGetAdapter(PropagationAdapter.class).ifPresent(propagationAdapter -> {
-                        if (propagationAdapter.propagate().isRejected()) {
-                                throw new IllegalArgumentException("Inconsistent initial mode: propagation failed");
-                        }
-                });
+                var propagationResult = model.tryGetAdapter(PropagationAdapter.class)
+                                .map(PropagationAdapter::propagate)
+                                .orElse(PropagationResult.UNCHANGED);
                 model.getAdapter(ModelQueryAdapter.class).flushChanges();
-                return model;
+                return new PropagatedModel(model, propagationResult);
         }
 
         @Override
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/PropagatedModel.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/PropagatedModel.java
new file mode 100644
index 00000000..42194a0e
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/PropagatedModel.java
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.seed;
+
+import tools.refinery.store.dse.propagation.PropagationResult;
+import tools.refinery.store.model.Model;
+
+public record PropagatedModel(Model model, PropagationResult propagationResult) {
+        public static final String PROPAGATION_FAILED_MESSAGE = "Inconsistent initial model: propagation failed";
+
+        public boolean isRejected() {
+                return propagationResult.isRejected();
+        }
+
+        public void throwIfRejected() {
+                if (isRejected()) {
+                        throw new IllegalArgumentException(PROPAGATION_FAILED_MESSAGE);
+                }
+        }
+}