feat: improve semantics error reporting

Also makes model seeds cancellable to reduce server load during semantic
analysis.

70 files changed, 1036 insertions, 300 deletions

diff --git a/subprojects/frontend/src/editor/AnalysisErrorNotification.tsx b/subprojects/frontend/src/editor/AnalysisErrorNotification.tsx
new file mode 100644
index 00000000..591a3600
--- /dev/null
+++ b/subprojects/frontend/src/editor/AnalysisErrorNotification.tsx
@@ -0,0 +1,74 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+import { reaction } from 'mobx';
+import { type SnackbarKey, useSnackbar } from 'notistack';
+import { useEffect, useState } from 'react';
+
+import type EditorStore from './EditorStore';
+
+function MessageObserver({
+  editorStore,
+}: {
+  editorStore: EditorStore;
+}): React.ReactNode {
+  const [message, setMessage] = useState(
+    editorStore.delayedErrors.semanticsError ?? '',
+  );
+  // Instead of making this component an `observer`,
+  // we only update the message is one is present to make sure that the
+  // disappear animation has a chance to complete.
+  useEffect(
+    () =>
+      reaction(
+        () => editorStore.delayedErrors.semanticsError,
+        (newMessage) => {
+          if (newMessage !== undefined) {
+            setMessage(newMessage);
+          }
+        },
+        { fireImmediately: false },
+      ),
+    [editorStore],
+  );
+  return message;
+}
+
+export default function AnalysisErrorNotification({
+  editorStore,
+}: {
+  editorStore: EditorStore;
+}): null {
+  const { enqueueSnackbar, closeSnackbar } = useSnackbar();
+  useEffect(() => {
+    let key: SnackbarKey | undefined;
+    const disposer = reaction(
+      () => editorStore.delayedErrors.semanticsError !== undefined,
+      (hasError) => {
+        if (hasError) {
+          if (key === undefined) {
+            key = enqueueSnackbar({
+              message: <MessageObserver editorStore={editorStore} />,
+              variant: 'error',
+              persist: true,
+            });
+          }
+        } else if (key !== undefined) {
+          closeSnackbar(key);
+          key = undefined;
+        }
+      },
+      { fireImmediately: true },
+    );
+    return () => {
+      disposer();
+      if (key !== undefined) {
+        closeSnackbar(key);
+      }
+    };
+  }, [editorStore, enqueueSnackbar, closeSnackbar]);
+  return null;
+}
diff --git a/subprojects/frontend/src/editor/AnimatedButton.tsx b/subprojects/frontend/src/editor/AnimatedButton.tsx
index dbbda618..24ec69be 100644
--- a/subprojects/frontend/src/editor/AnimatedButton.tsx
+++ b/subprojects/frontend/src/editor/AnimatedButton.tsx
@@ -48,7 +48,7 @@ export default function AnimatedButton({
   onClick?: () => void;
   color: 'error' | 'warning' | 'primary' | 'inherit';
   disabled?: boolean;
-  startIcon: JSX.Element;
+  startIcon?: JSX.Element;
   sx?: SxProps<Theme> | undefined;
   children?: ReactNode;
 }): JSX.Element {
@@ -79,7 +79,11 @@ export default function AnimatedButton({
       className="rounded shaded"
       disabled={disabled ?? false}
       startIcon={startIcon}
-      width={width === undefined ? 'auto' : `calc(${width} + 50px)`}
+      width={
+        width === undefined
+          ? 'auto'
+          : `calc(${width} + ${startIcon === undefined ? 28 : 50}px)`
+      }
     >
       <Box
         display="flex"
@@ -100,6 +104,7 @@ AnimatedButton.defaultProps = {
   'aria-label': undefined,
   onClick: undefined,
   disabled: false,
+  startIcon: undefined,
   sx: undefined,
   children: undefined,
 };
diff --git a/subprojects/frontend/src/editor/EditorButtons.tsx b/subprojects/frontend/src/editor/EditorButtons.tsx
index 9b187e5c..ca51f975 100644
--- a/subprojects/frontend/src/editor/EditorButtons.tsx
+++ b/subprojects/frontend/src/editor/EditorButtons.tsx
@@ -5,8 +5,8 @@
  */
 
 import type { Diagnostic } from '@codemirror/lint';
+import CancelIcon from '@mui/icons-material/Cancel';
 import CheckIcon from '@mui/icons-material/Check';
-import ErrorIcon from '@mui/icons-material/Error';
 import FormatListNumberedIcon from '@mui/icons-material/FormatListNumbered';
 import FormatPaint from '@mui/icons-material/FormatPaint';
 import InfoOutlinedIcon from '@mui/icons-material/InfoOutlined';
@@ -28,7 +28,7 @@ import type EditorStore from './EditorStore';
 function getLintIcon(severity: Diagnostic['severity'] | undefined) {
   switch (severity) {
     case 'error':
-      return <ErrorIcon fontSize="small" />;
+      return <CancelIcon fontSize="small" />;
     case 'warning':
       return <WarningIcon fontSize="small" />;
     case 'info':
@@ -95,7 +95,7 @@ export default observer(function EditorButtons({
             })}
           value="show-lint-panel"
         >
-          {getLintIcon(editorStore?.highestDiagnosticLevel)}
+          {getLintIcon(editorStore?.delayedErrors?.highestDiagnosticLevel)}
         </ToggleButton>
       </ToggleButtonGroup>
       <IconButton
diff --git a/subprojects/frontend/src/editor/EditorErrors.tsx b/subprojects/frontend/src/editor/EditorErrors.tsx
new file mode 100644
index 00000000..40becf7e
--- /dev/null
+++ b/subprojects/frontend/src/editor/EditorErrors.tsx
@@ -0,0 +1,93 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+import { Diagnostic } from '@codemirror/lint';
+import { type IReactionDisposer, makeAutoObservable, reaction } from 'mobx';
+
+import type EditorStore from './EditorStore';
+
+const HYSTERESIS_TIME_MS = 250;
+
+export interface State {
+  analyzing: boolean;
+  errorCount: number;
+  warningCount: number;
+  infoCount: number;
+  semanticsError: string | undefined;
+}
+
+export default class EditorErrors implements State {
+  private readonly disposer: IReactionDisposer;
+
+  private timer: number | undefined;
+
+  analyzing = false;
+
+  errorCount = 0;
+
+  warningCount = 0;
+
+  infoCount = 0;
+
+  semanticsError: string | undefined;
+
+  constructor(private readonly store: EditorStore) {
+    this.updateImmediately(this.getNextState());
+    makeAutoObservable<EditorErrors, 'disposer' | 'timer'>(this, {
+      disposer: false,
+      timer: false,
+    });
+    this.disposer = reaction(
+      () => this.getNextState(),
+      (nextState) => {
+        if (this.timer !== undefined) {
+          clearTimeout(this.timer);
+          this.timer = undefined;
+        }
+        if (nextState.analyzing) {
+          this.timer = setTimeout(
+            () => this.updateImmediately(nextState),
+            HYSTERESIS_TIME_MS,
+          );
+        } else {
+          this.updateImmediately(nextState);
+        }
+      },
+      { fireImmediately: true },
+    );
+  }
+
+  get highestDiagnosticLevel(): Diagnostic['severity'] | undefined {
+    if (this.errorCount > 0) {
+      return 'error';
+    }
+    if (this.warningCount > 0) {
+      return 'warning';
+    }
+    if (this.infoCount > 0) {
+      return 'info';
+    }
+    return undefined;
+  }
+
+  private getNextState(): State {
+    return {
+      analyzing: this.store.analyzing,
+      errorCount: this.store.errorCount,
+      warningCount: this.store.warningCount,
+      infoCount: this.store.infoCount,
+      semanticsError: this.store.semanticsError,
+    };
+  }
+
+  private updateImmediately(nextState: State) {
+    Object.assign(this, nextState);
+  }
+
+  dispose() {
+    this.disposer();
+  }
+}
diff --git a/subprojects/frontend/src/editor/EditorPane.tsx b/subprojects/frontend/src/editor/EditorPane.tsx
index c9f86496..1125a0ec 100644
--- a/subprojects/frontend/src/editor/EditorPane.tsx
+++ b/subprojects/frontend/src/editor/EditorPane.tsx
@@ -13,6 +13,7 @@ import { useState } from 'react';
 
 import { useRootStore } from '../RootStoreProvider';
 
+import AnalysisErrorNotification from './AnalysisErrorNotification';
 import ConnectionStatusNotification from './ConnectionStatusNotification';
 import EditorArea from './EditorArea';
 import EditorButtons from './EditorButtons';
@@ -48,6 +49,7 @@ export default observer(function EditorPane(): JSX.Element {
           <EditorLoading />
         ) : (
           <>
+            <AnalysisErrorNotification editorStore={editorStore} />
             <ConnectionStatusNotification editorStore={editorStore} />
             <SearchPanelPortal editorStore={editorStore} />
             <EditorArea editorStore={editorStore} />
diff --git a/subprojects/frontend/src/editor/EditorStore.ts b/subprojects/frontend/src/editor/EditorStore.ts
index c79f6ec1..563725bb 100644
--- a/subprojects/frontend/src/editor/EditorStore.ts
+++ b/subprojects/frontend/src/editor/EditorStore.ts
@@ -29,6 +29,7 @@ import type PWAStore from '../PWAStore';
 import getLogger from '../utils/getLogger';
 import type XtextClient from '../xtext/XtextClient';
 
+import EditorErrors from './EditorErrors';
 import LintPanelStore from './LintPanelStore';
 import SearchPanelStore from './SearchPanelStore';
 import createEditorState from './createEditorState';
@@ -54,15 +55,22 @@ export default class EditorStore {
 
   readonly lintPanel: LintPanelStore;
 
+  readonly delayedErrors: EditorErrors;
+
   showLineNumbers = false;
 
   disposed = false;
 
+  analyzing = false;
+
+  semanticsError: string | undefined;
+
   semantics: unknown = {};
 
   constructor(initialValue: string, pwaStore: PWAStore) {
     this.id = nanoid();
     this.state = createEditorState(initialValue, this);
+    this.delayedErrors = new EditorErrors(this);
     this.searchPanel = new SearchPanelStore(this);
     this.lintPanel = new LintPanelStore(this);
     (async () => {
@@ -82,6 +90,7 @@ export default class EditorStore {
       state: observable.ref,
       client: observable.ref,
       view: observable.ref,
+      semantics: observable.ref,
       searchPanel: false,
       lintPanel: false,
       contentAssist: false,
@@ -215,19 +224,6 @@ export default class EditorStore {
     this.doCommand(nextDiagnostic);
   }
 
-  get highestDiagnosticLevel(): Diagnostic['severity'] | undefined {
-    if (this.errorCount > 0) {
-      return 'error';
-    }
-    if (this.warningCount > 0) {
-      return 'warning';
-    }
-    if (this.infoCount > 0) {
-      return 'info';
-    }
-    return undefined;
-  }
-
   updateSemanticHighlighting(ranges: IHighlightRange[]): void {
     this.dispatch(setSemanticHighlighting(ranges));
   }
@@ -284,12 +280,29 @@ export default class EditorStore {
     return true;
   }
 
+  analysisStarted() {
+    this.analyzing = true;
+  }
+
+  analysisCompleted(semanticAnalysisSkipped = false) {
+    this.analyzing = false;
+    if (semanticAnalysisSkipped) {
+      this.semanticsError = undefined;
+    }
+  }
+
+  setSemanticsError(semanticsError: string) {
+    this.semanticsError = semanticsError;
+  }
+
   setSemantics(semantics: unknown) {
+    this.semanticsError = undefined;
     this.semantics = semantics;
   }
 
   dispose(): void {
     this.client?.dispose();
+    this.delayedErrors.dispose();
     this.disposed = true;
   }
 }
diff --git a/subprojects/frontend/src/editor/EditorTheme.ts b/subprojects/frontend/src/editor/EditorTheme.ts
index 4afb93e6..dd551a52 100644
--- a/subprojects/frontend/src/editor/EditorTheme.ts
+++ b/subprojects/frontend/src/editor/EditorTheme.ts
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: EPL-2.0
  */
 
-import errorSVG from '@material-icons/svg/svg/error/baseline.svg?raw';
+import cancelSVG from '@material-icons/svg/svg/cancel/baseline.svg?raw';
 import expandMoreSVG from '@material-icons/svg/svg/expand_more/baseline.svg?raw';
 import infoSVG from '@material-icons/svg/svg/info/baseline.svg?raw';
 import warningSVG from '@material-icons/svg/svg/warning/baseline.svg?raw';
@@ -331,7 +331,7 @@ export default styled('div', {
     '.cm-lintRange-active': {
       background: theme.palette.highlight.activeLintRange,
     },
-    ...lintSeverityStyle('error', errorSVG, 120),
+    ...lintSeverityStyle('error', cancelSVG, 120),
     ...lintSeverityStyle('warning', warningSVG, 110),
     ...lintSeverityStyle('info', infoSVG, 100),
   };
diff --git a/subprojects/frontend/src/editor/GenerateButton.tsx b/subprojects/frontend/src/editor/GenerateButton.tsx
index 3837ef8e..5bac0464 100644
--- a/subprojects/frontend/src/editor/GenerateButton.tsx
+++ b/subprojects/frontend/src/editor/GenerateButton.tsx
@@ -4,10 +4,8 @@
  * SPDX-License-Identifier: EPL-2.0
  */
 
-import DangerousOutlinedIcon from '@mui/icons-material/DangerousOutlined';
+import CancelIcon from '@mui/icons-material/Cancel';
 import PlayArrowIcon from '@mui/icons-material/PlayArrow';
-import Button from '@mui/material/Button';
-import type { SxProps, Theme } from '@mui/material/styles';
 import { observer } from 'mobx-react-lite';
 
 import AnimatedButton from './AnimatedButton';
@@ -18,26 +16,45 @@ const GENERATE_LABEL = 'Generate';
 const GenerateButton = observer(function GenerateButton({
   editorStore,
   hideWarnings,
-  sx,
 }: {
   editorStore: EditorStore | undefined;
   hideWarnings?: boolean | undefined;
-  sx?: SxProps<Theme> | undefined;
 }): JSX.Element {
   if (editorStore === undefined) {
     return (
-      <Button
-        color="inherit"
-        className="rounded shaded"
-        disabled
-        {...(sx === undefined ? {} : { sx })}
-      >
+      <AnimatedButton color="inherit" disabled>
         Loading&hellip;
-      </Button>
+      </AnimatedButton>
+    );
+  }
+
+  const { analyzing, errorCount, warningCount, semanticsError } =
+    editorStore.delayedErrors;
+
+  if (analyzing) {
+    return (
+      <AnimatedButton color="inherit" disabled>
+        Analyzing&hellip;
+      </AnimatedButton>
     );
   }
 
-  const { errorCount, warningCount } = editorStore;
+  if (semanticsError !== undefined && editorStore.opened) {
+    return (
+      <AnimatedButton
+        color="error"
+        disabled
+        startIcon={<CancelIcon />}
+        sx={(theme) => ({
+          '&.Mui-disabled': {
+            color: `${theme.palette.error.main} !important`,
+          },
+        })}
+      >
+        Analysis error
+      </AnimatedButton>
+    );
+  }
 
   const diagnostics: string[] = [];
   if (errorCount > 0) {
@@ -54,8 +71,7 @@ const GenerateButton = observer(function GenerateButton({
         aria-label={`Select next diagnostic out of ${summary}`}
         onClick={() => editorStore.nextDiagnostic()}
         color="error"
-        startIcon={<DangerousOutlinedIcon />}
-        {...(sx === undefined ? {} : { sx })}
+        startIcon={<CancelIcon />}
       >
         {summary}
       </AnimatedButton>
@@ -67,7 +83,6 @@ const GenerateButton = observer(function GenerateButton({
       disabled={!editorStore.opened}
       color={warningCount > 0 ? 'warning' : 'primary'}
       startIcon={<PlayArrowIcon />}
-      {...(sx === undefined ? {} : { sx })}
     >
       {summary === '' ? GENERATE_LABEL : `${GENERATE_LABEL} (${summary})`}
     </AnimatedButton>
@@ -76,7 +91,6 @@ const GenerateButton = observer(function GenerateButton({
 
 GenerateButton.defaultProps = {
   hideWarnings: false,
-  sx: undefined,
 };
 
 export default GenerateButton;
diff --git a/subprojects/frontend/src/xtext/SemanticsService.ts b/subprojects/frontend/src/xtext/SemanticsService.ts
new file mode 100644
index 00000000..50ec371a
--- /dev/null
+++ b/subprojects/frontend/src/xtext/SemanticsService.ts
@@ -0,0 +1,28 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+import type EditorStore from '../editor/EditorStore';
+
+import type ValidationService from './ValidationService';
+import { SemanticsResult } from './xtextServiceResults';
+
+export default class SemanticsService {
+  constructor(
+    private readonly store: EditorStore,
+    private readonly validationService: ValidationService,
+  ) {}
+
+  onPush(push: unknown): void {
+    const result = SemanticsResult.parse(push);
+    this.validationService.setSemanticsIssues(result.issues ?? []);
+    if (result.error !== undefined) {
+      this.store.setSemanticsError(result.error);
+    } else {
+      this.store.setSemantics(push);
+    }
+    this.store.analysisCompleted();
+  }
+}
diff --git a/subprojects/frontend/src/xtext/UpdateService.ts b/subprojects/frontend/src/xtext/UpdateService.ts
index ee5ebde2..1ac722e1 100644
--- a/subprojects/frontend/src/xtext/UpdateService.ts
+++ b/subprojects/frontend/src/xtext/UpdateService.ts
@@ -133,6 +133,7 @@ export default class UpdateService {
       return;
     }
     log.trace('Editor delta', delta);
+    this.store.analysisStarted();
     const result = await this.webSocketClient.send({
       resource: this.resourceName,
       serviceType: 'update',
@@ -157,6 +158,7 @@ export default class UpdateService {
   private async updateFullTextExclusive(): Promise<void> {
     log.debug('Performing full text update');
     this.tracker.prepareFullTextUpdateExclusive();
+    this.store.analysisStarted();
     const result = await this.webSocketClient.send({
       resource: this.resourceName,
       serviceType: 'update',
diff --git a/subprojects/frontend/src/xtext/ValidationService.ts b/subprojects/frontend/src/xtext/ValidationService.ts
index 64fb63eb..1a896db3 100644
--- a/subprojects/frontend/src/xtext/ValidationService.ts
+++ b/subprojects/frontend/src/xtext/ValidationService.ts
@@ -9,7 +9,7 @@ import type { Diagnostic } from '@codemirror/lint';
 import type EditorStore from '../editor/EditorStore';
 
 import type UpdateService from './UpdateService';
-import { ValidationResult } from './xtextServiceResults';
+import { Issue, ValidationResult } from './xtextServiceResults';
 
 export default class ValidationService {
   constructor(
@@ -17,11 +17,41 @@ export default class ValidationService {
     private readonly updateService: UpdateService,
   ) {}
 
+  private lastValidationIssues: Issue[] = [];
+
+  private lastSemanticsIssues: Issue[] = [];
+
   onPush(push: unknown): void {
-    const { issues } = ValidationResult.parse(push);
+    ({ issues: this.lastValidationIssues } = ValidationResult.parse(push));
+    this.lastSemanticsIssues = [];
+    this.updateDiagnostics();
+    if (
+      this.lastValidationIssues.some(({ severity }) => severity === 'error')
+    ) {
+      this.store.analysisCompleted(true);
+    }
+  }
+
+  onDisconnect(): void {
+    this.store.updateDiagnostics([]);
+    this.lastValidationIssues = [];
+    this.lastSemanticsIssues = [];
+  }
+
+  setSemanticsIssues(issues: Issue[]): void {
+    this.lastSemanticsIssues = issues;
+    this.updateDiagnostics();
+  }
+
+  private updateDiagnostics(): void {
     const allChanges = this.updateService.computeChangesSinceLastUpdate();
     const diagnostics: Diagnostic[] = [];
-    issues.forEach(({ offset, length, severity, description }) => {
+    function createDiagnostic({
+      offset,
+      length,
+      severity,
+      description,
+    }: Issue): void {
       if (severity === 'ignore') {
         return;
       }
@@ -31,11 +61,9 @@ export default class ValidationService {
         severity,
         message: description,
       });
-    });
+    }
+    this.lastValidationIssues.forEach(createDiagnostic);
+    this.lastSemanticsIssues.forEach(createDiagnostic);
     this.store.updateDiagnostics(diagnostics);
   }
-
-  onDisconnect(): void {
-    this.store.updateDiagnostics([]);
-  }
 }
diff --git a/subprojects/frontend/src/xtext/XtextClient.ts b/subprojects/frontend/src/xtext/XtextClient.ts
index d145cd30..87778084 100644
--- a/subprojects/frontend/src/xtext/XtextClient.ts
+++ b/subprojects/frontend/src/xtext/XtextClient.ts
@@ -17,6 +17,7 @@ import getLogger from '../utils/getLogger';
 import ContentAssistService from './ContentAssistService';
 import HighlightingService from './HighlightingService';
 import OccurrencesService from './OccurrencesService';
+import SemanticsService from './SemanticsService';
 import UpdateService from './UpdateService';
 import ValidationService from './ValidationService';
 import XtextWebSocketClient from './XtextWebSocketClient';
@@ -37,6 +38,8 @@ export default class XtextClient {
 
   private readonly occurrencesService: OccurrencesService;
 
+  private readonly semanticsService: SemanticsService;
+
   constructor(
     private readonly store: EditorStore,
     private readonly pwaStore: PWAStore,
@@ -54,6 +57,7 @@ export default class XtextClient {
     );
     this.validationService = new ValidationService(store, this.updateService);
     this.occurrencesService = new OccurrencesService(store, this.updateService);
+    this.semanticsService = new SemanticsService(store, this.validationService);
   }
 
   start(): void {
@@ -67,6 +71,7 @@ export default class XtextClient {
   }
 
   private onDisconnect(): void {
+    this.store.analysisCompleted(true);
     this.highlightingService.onDisconnect();
     this.validationService.onDisconnect();
     this.occurrencesService.onDisconnect();
@@ -115,7 +120,7 @@ export default class XtextClient {
         this.validationService.onPush(push);
         return;
       case 'semantics':
-        this.store.setSemantics(push);
+        this.semanticsService.onPush(push);
         return;
       default:
         throw new Error('Unknown service');
diff --git a/subprojects/frontend/src/xtext/xtextServiceResults.ts b/subprojects/frontend/src/xtext/xtextServiceResults.ts
index d3b467ad..cae95771 100644
--- a/subprojects/frontend/src/xtext/xtextServiceResults.ts
+++ b/subprojects/frontend/src/xtext/xtextServiceResults.ts
@@ -125,3 +125,10 @@ export const FormattingResult = DocumentStateResult.extend({
 });
 
 export type FormattingResult = z.infer<typeof FormattingResult>;
+
+export const SemanticsResult = z.object({
+  error: z.string().optional(),
+  issues: Issue.array().optional(),
+});
+
+export type SemanticsResult = z.infer<typeof SemanticsResult>;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
index 5f854ac3..5ed65e04 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
@@ -15,12 +15,14 @@ import tools.refinery.language.utils.ProblemDesugarer;
 import tools.refinery.language.utils.ProblemUtil;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.dnf.InvalidClauseException;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.query.literal.*;
 import tools.refinery.store.query.term.NodeVariable;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.seed.ModelSeed;
 import tools.refinery.store.reasoning.seed.Seed;
@@ -60,7 +62,9 @@ public class ModelInitializer {
 
         private final Map<Relation, RelationInfo> relationInfoMap = new LinkedHashMap<>();
 
-        private final Map<PartialRelation, RelationInfo> partialRelationInfoMap = new LinkedHashMap<>();
+        private final Map<PartialRelation, RelationInfo> partialRelationInfoMap = new HashMap<>();
+
+        private Map<AnyPartialSymbol, Relation> inverseTrace = new HashMap<>();
 
         private Map<Relation, PartialRelation> relationTrace;
 
@@ -82,6 +86,10 @@ public class ModelInitializer {
                 return relationTrace;
         }
 
+        public Relation getInverseTrace(AnyPartialSymbol partialRelation) {
+                return inverseTrace.get(partialRelation);
+        }
+
         public ModelSeed createModel(Problem problem, ModelStoreBuilder storeBuilder) {
                 this.problem = problem;
                 this.storeBuilder = storeBuilder;
@@ -172,7 +180,7 @@ public class ModelInitializer {
                                         collectPartialRelation(invalidMultiplicityConstraint, 1, TruthValue.FALSE, TruthValue.FALSE);
                                 }
                         } else {
-                                throw new IllegalArgumentException("Unknown feature declaration: " + featureDeclaration);
+                                throw new TracedException(featureDeclaration, "Unknown feature declaration");
                         }
                 }
         }
@@ -189,6 +197,7 @@ public class ModelInitializer {
         private void putRelationInfo(Relation relation, RelationInfo info) {
                 relationInfoMap.put(relation, info);
                 partialRelationInfoMap.put(info.partialRelation(), info);
+                inverseTrace.put(info.partialRelation(), relation);
         }
 
         private RelationInfo collectPartialRelation(Relation relation, int arity, TruthValue value,
@@ -197,6 +206,7 @@ public class ModelInitializer {
                         var name = getName(relation);
                         var info = new RelationInfo(name, arity, value, defaultValue);
                         partialRelationInfoMap.put(info.partialRelation(), info);
+                        inverseTrace.put(info.partialRelation(), relation);
                         return info;
                 });
         }
@@ -216,7 +226,11 @@ public class ModelInitializer {
         }
 
         private void collectEnumMetamodel(EnumDeclaration enumDeclaration) {
-                metamodelBuilder.type(getPartialRelation(enumDeclaration), nodeRelation);
+                try {
+                        metamodelBuilder.type(getPartialRelation(enumDeclaration), nodeRelation);
+                } catch (RuntimeException e) {
+                        throw TracedException.addTrace(enumDeclaration, e);
+                }
         }
 
         private void collectClassDeclarationMetamodel(ClassDeclaration classDeclaration) {
@@ -226,13 +240,15 @@ public class ModelInitializer {
                 for (var superType : superTypes) {
                         partialSuperTypes.add(getPartialRelation(superType));
                 }
-                metamodelBuilder.type(getPartialRelation(classDeclaration), classDeclaration.isAbstract(),
-                                partialSuperTypes);
+                try {
+                        metamodelBuilder.type(getPartialRelation(classDeclaration), classDeclaration.isAbstract(),
+                                        partialSuperTypes);
+                } catch (RuntimeException e) {
+                        throw TracedException.addTrace(classDeclaration, e);
+                }
                 for (var featureDeclaration : classDeclaration.getFeatureDeclarations()) {
                         if (featureDeclaration instanceof ReferenceDeclaration referenceDeclaration) {
                                 collectReferenceDeclarationMetamodel(classDeclaration, referenceDeclaration);
-                        } else {
-                                throw new IllegalArgumentException("Unknown feature declaration: " + featureDeclaration);
                         }
                 }
         }
@@ -249,7 +265,11 @@ public class ModelInitializer {
                         oppositeRelation = getPartialRelation(opposite);
                 }
                 var multiplicity = getMultiplicityConstraint(referenceDeclaration);
-                metamodelBuilder.reference(relation, source, containment, multiplicity, target, oppositeRelation);
+                try {
+                        metamodelBuilder.reference(relation, source, containment, multiplicity, target, oppositeRelation);
+                } catch (RuntimeException e) {
+                        throw TracedException.addTrace(classDeclaration, e);
+                }
         }
 
         private Multiplicity getMultiplicityConstraint(ReferenceDeclaration referenceDeclaration) {
@@ -267,7 +287,7 @@ public class ModelInitializer {
                         interval = CardinalityIntervals.between(rangeMultiplicity.getLowerBound(),
                                         upperBound < 0 ? UpperCardinalities.UNBOUNDED : UpperCardinalities.atMost(upperBound));
                 } else {
-                        throw new IllegalArgumentException("Unknown multiplicity: " + problemMultiplicity);
+                        throw new TracedException(problemMultiplicity, "Unknown multiplicity");
                 }
                 var constraint = getRelationInfo(referenceDeclaration.getInvalidMultiplicity()).partialRelation();
                 return ConstrainedMultiplicity.of(interval, constraint);
@@ -327,13 +347,19 @@ public class ModelInitializer {
         }
 
         private void collectAssertion(Assertion assertion) {
-                var relation = assertion.getRelation();
                 var tuple = getTuple(assertion);
                 var value = getTruthValue(assertion.getValue());
+                var relation = assertion.getRelation();
+                var info = getRelationInfo(relation);
+                var partialRelation = info.partialRelation();
+                if (partialRelation.arity() != tuple.getSize()) {
+                        throw new TracedException(assertion, "Expected %d arguments for %s, got %d instead"
+                                        .formatted(partialRelation.arity(), partialRelation, tuple.getSize()));
+                }
                 if (assertion.isDefault()) {
-                        mergeDefaultValue(relation, tuple, value);
+                        info.defaultAssertions().mergeValue(tuple, value);
                 } else {
-                        mergeValue(relation, tuple, value);
+                        info.assertions().mergeValue(tuple, value);
                 }
         }
 
@@ -341,10 +367,6 @@ public class ModelInitializer {
                 getRelationInfo(relation).assertions().mergeValue(key, value);
         }
 
-        private void mergeDefaultValue(Relation relation, Tuple key, TruthValue value) {
-                getRelationInfo(relation).defaultAssertions().mergeValue(key, value);
-        }
-
         private RelationInfo getRelationInfo(Relation relation) {
                 var info = relationInfoMap.get(relation);
                 if (info == null) {
@@ -372,7 +394,7 @@ public class ModelInitializer {
                         } else if (argument instanceof WildcardAssertionArgument) {
                                 nodes[i] = -1;
                         } else {
-                                throw new IllegalArgumentException("Unknown assertion argument: " + argument);
+                                throw new TracedException(argument, "Unsupported assertion argument");
                         }
                 }
                 return Tuple.of(nodes);
@@ -393,8 +415,24 @@ public class ModelInitializer {
         private void collectPredicates() {
                 for (var statement : problem.getStatements()) {
                         if (statement instanceof PredicateDefinition predicateDefinition) {
-                                collectPredicateDefinition(predicateDefinition);
+                                collectPredicateDefinitionTraced(predicateDefinition);
+                        }
+                }
+        }
+
+        private void collectPredicateDefinitionTraced(PredicateDefinition predicateDefinition) {
+                try {
+                        collectPredicateDefinition(predicateDefinition);
+                } catch (InvalidClauseException e) {
+                        int clauseIndex = e.getClauseIndex();
+                        var bodies = predicateDefinition.getBodies();
+                        if (clauseIndex < bodies.size()) {
+                                throw new TracedException(bodies.get(clauseIndex), e);
+                        } else {
+                                throw new TracedException(predicateDefinition, e);
                         }
+                } catch (RuntimeException e) {
+                        throw TracedException.addTrace(predicateDefinition, e);
                 }
         }
 
@@ -436,13 +474,17 @@ public class ModelInitializer {
                 }
                 var builder = Query.builder(name).parameters(parameters);
                 for (var body : predicateDefinition.getBodies()) {
-                        var localScope = extendScope(parameterMap, body.getImplicitVariables());
-                        var problemLiterals = body.getLiterals();
-                        var literals = new ArrayList<Literal>(commonLiterals);
-                        for (var problemLiteral : problemLiterals) {
-                                toLiterals(problemLiteral, localScope, literals);
+                        try {
+                                var localScope = extendScope(parameterMap, body.getImplicitVariables());
+                                var problemLiterals = body.getLiterals();
+                                var literals = new ArrayList<>(commonLiterals);
+                                for (var problemLiteral : problemLiterals) {
+                                        toLiteralsTraced(problemLiteral, localScope, literals);
+                                }
+                                builder.clause(literals);
+                        } catch (RuntimeException e) {
+                                throw TracedException.addTrace(body, e);
                         }
-                        builder.clause(literals);
                 }
                 return builder.build();
         }
@@ -462,13 +504,23 @@ public class ModelInitializer {
                 return localScope;
         }
 
-        private void toLiterals(Expr expr, Map<tools.refinery.language.model.problem.Variable, Variable> localScope,
+        private void toLiteralsTraced(Expr expr, Map<tools.refinery.language.model.problem.Variable, Variable> localScope,
+                                                                  List<Literal> literals) {
+                try {
+                        toLiterals(expr, localScope, literals);
+                } catch (RuntimeException e) {
+                        throw TracedException.addTrace(expr, e);
+                }
+        }
+
+        private void toLiterals(Expr expr, Map<tools.refinery.language.model.problem.Variable,
+                        Variable> localScope,
                                                         List<Literal> literals) {
                 if (expr instanceof LogicConstant logicConstant) {
                         switch (logicConstant.getLogicValue()) {
-                                case TRUE -> literals.add(BooleanLiteral.TRUE);
-                                case FALSE -> literals.add(BooleanLiteral.FALSE);
-                                default -> throw new IllegalArgumentException("Unsupported literal: " + expr);
+                        case TRUE -> literals.add(BooleanLiteral.TRUE);
+                        case FALSE -> literals.add(BooleanLiteral.FALSE);
+                        default -> throw new TracedException(logicConstant, "Unsupported literal");
                         }
                 } else if (expr instanceof Atom atom) {
                         var target = getPartialRelation(atom.getRelation());
@@ -478,7 +530,7 @@ public class ModelInitializer {
                 } else if (expr instanceof NegationExpr negationExpr) {
                         var body = negationExpr.getBody();
                         if (!(body instanceof Atom atom)) {
-                                throw new IllegalArgumentException("Cannot negate literal: " + body);
+                                throw new TracedException(body, "Cannot negate literal");
                         }
                         var target = getPartialRelation(atom.getRelation());
                         Constraint constraint;
@@ -498,11 +550,12 @@ public class ModelInitializer {
                         boolean positive = switch (comparisonExpr.getOp()) {
                                 case EQ -> true;
                                 case NOT_EQ -> false;
-                                default -> throw new IllegalArgumentException("Unsupported operator: " + comparisonExpr.getOp());
+                                default -> throw new TracedException(
+                                                comparisonExpr, "Unsupported operator");
                         };
                         literals.add(new EquivalenceLiteral(positive, argumentList.get(0), argumentList.get(1)));
                 } else {
-                        throw new IllegalArgumentException("Unsupported literal: " + expr);
+                        throw new TracedException(expr, "Unsupported literal");
                 }
         }
 
@@ -512,7 +565,7 @@ public class ModelInitializer {
                 var argumentList = new ArrayList<Variable>(expressions.size());
                 for (var expr : expressions) {
                         if (!(expr instanceof VariableOrNodeExpr variableOrNodeExpr)) {
-                                throw new IllegalArgumentException("Unsupported argument: " + expr);
+                                throw new TracedException(expr, "Unsupported argument");
                         }
                         var variableOrNode = variableOrNodeExpr.getVariableOrNode();
                         if (variableOrNode instanceof Node node) {
@@ -526,10 +579,12 @@ public class ModelInitializer {
                                 } else {
                                         var variable = localScope.get(problemVariable);
                                         if (variable == null) {
-                                                throw new IllegalArgumentException("Unknown variable: " + problemVariable.getName());
+                                                throw new TracedException(variableOrNode, "Unknown variable: " + problemVariable.getName());
                                         }
                                         argumentList.add(variable);
                                 }
+                        } else {
+                                throw new TracedException(variableOrNode, "Unknown argument");
                         }
                 }
                 return argumentList;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/TracedException.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/TracedException.java
new file mode 100644
index 00000000..38fd8a67
--- /dev/null
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/TracedException.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.semantics.model;
+
+import org.eclipse.emf.ecore.EObject;
+
+public class TracedException extends RuntimeException {
+        private final transient EObject sourceElement;
+
+        public TracedException(EObject sourceElement) {
+                this.sourceElement = sourceElement;
+        }
+
+        public TracedException(EObject sourceElement, String message) {
+                super(message);
+                this.sourceElement = sourceElement;
+        }
+
+        public TracedException(EObject sourceElement, String message, Throwable cause) {
+                super(message, cause);
+                this.sourceElement = sourceElement;
+        }
+
+        public TracedException(EObject sourceElement, Throwable cause) {
+                super(cause);
+                this.sourceElement = sourceElement;
+        }
+
+        public EObject getSourceElement() {
+                return sourceElement;
+        }
+
+        @Override
+        public String getMessage() {
+                var message = super.getMessage();
+                if (message == null) {
+                        return "Internal error";
+                }
+                return message;
+        }
+
+        public static TracedException addTrace(EObject sourceElement, Throwable cause) {
+                if (cause instanceof TracedException tracedException && tracedException.sourceElement != null) {
+                        return tracedException;
+                }
+                return new TracedException(sourceElement, cause);
+        }
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/CancellableSeed.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/CancellableSeed.java
new file mode 100644
index 00000000..aa14f39d
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/CancellableSeed.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.semantics;
+
+import tools.refinery.store.map.AnyVersionedMap;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.seed.Seed;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.viatra.runtime.CancellationToken;
+
+import java.util.Set;
+
+class CancellableSeed<T> implements Seed<T> {
+        private final CancellationToken cancellationToken;
+        private final Seed<T> seed;
+
+        private CancellableSeed(CancellationToken cancellationToken, Seed<T> seed) {
+                this.cancellationToken = cancellationToken;
+                this.seed = seed;
+        }
+
+        @Override
+        public int arity() {
+                return seed.arity();
+        }
+
+        @Override
+        public Class<T> valueType() {
+                return seed.valueType();
+        }
+
+        @Override
+        public T reducedValue() {
+                return seed.reducedValue();
+        }
+
+        @Override
+        public T get(Tuple key) {
+                return seed.get(key);
+        }
+
+        @Override
+        public Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount) {
+                return new CancellableCursor<>(cancellationToken, seed.getCursor(defaultValue, nodeCount));
+        }
+
+        public static ModelSeed wrap(CancellationToken cancellationToken, ModelSeed modelSeed) {
+                var builder = ModelSeed.builder(modelSeed.getNodeCount());
+                for (var partialSymbol : modelSeed.getSeededSymbols()) {
+                        wrap(cancellationToken, (PartialSymbol<?, ?>) partialSymbol, modelSeed, builder);
+                }
+                return builder.build();
+        }
+
+        private static <A, C> void wrap(CancellationToken cancellationToken, PartialSymbol<A, C> partialSymbol,
+                                                                        ModelSeed originalModelSeed, ModelSeed.Builder builder) {
+                var originalSeed = originalModelSeed.getSeed(partialSymbol);
+                builder.seed(partialSymbol, new CancellableSeed<>(cancellationToken, originalSeed));
+        }
+
+        private record CancellableCursor<T>(CancellationToken cancellationToken, Cursor<Tuple, T> cursor)
+                        implements Cursor<Tuple, T> {
+                @Override
+                public Tuple getKey() {
+                        return cursor.getKey();
+                }
+
+                @Override
+                public T getValue() {
+                        return cursor.getValue();
+                }
+
+                @Override
+                public boolean isTerminated() {
+                        return cursor.isTerminated();
+                }
+
+                @Override
+                public boolean move() {
+                        cancellationToken.checkCancelled();
+                        return cursor.move();
+                }
+
+                @Override
+                public boolean isDirty() {
+                        return cursor.isDirty();
+                }
+
+                @Override
+                public Set<AnyVersionedMap> getDependingMaps() {
+                        return cursor.getDependingMaps();
+                }
+        }
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsErrorResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsInternalErrorResult.java
index ce34ef6c..ff592e93 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsErrorResult.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsInternalErrorResult.java
@@ -5,5 +5,5 @@
  */
 package tools.refinery.language.web.semantics;
 
-public record SemanticsErrorResult(String error) implements SemanticsResult {
+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
new file mode 100644
index 00000000..644bd179
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsIssuesResult.java
@@ -0,0 +1,13 @@
+/*
+ * 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/SemanticsResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsResult.java
index 92639578..a2e19a2f 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
@@ -7,5 +7,6 @@ package tools.refinery.language.web.semantics;
 
 import org.eclipse.xtext.web.server.IServiceResult;
 
-public sealed interface SemanticsResult extends IServiceResult permits SemanticsSuccessResult, SemanticsErrorResult {
+public sealed interface SemanticsResult extends IServiceResult permits SemanticsSuccessResult,
+                SemanticsInternalErrorResult, SemanticsIssuesResult {
 }
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 39191162..56b2cbc1 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,9 +5,11 @@
  */
 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;
+import org.eclipse.xtext.ide.ExecutorServiceProvider;
 import org.eclipse.xtext.service.OperationCanceledManager;
 import org.eclipse.xtext.util.CancelIndicator;
 import org.eclipse.xtext.web.server.model.AbstractCachedService;
@@ -19,6 +21,7 @@ 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.concurrent.*;
 
 @Singleton
@@ -34,7 +37,12 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
         @Inject
         private ValidationService validationService;
 
-        private final ExecutorService executorService = Executors.newCachedThreadPool();
+        private ExecutorService executorService;
+
+        @Inject
+        public void setExecutorServiceProvider(ExecutorServiceProvider provider) {
+                executorService = provider.get(this.getClass().getName());
+        }
 
         @Override
         public SemanticsResult compute(IXtextWebDocument doc, CancelIndicator cancelIndicator) {
@@ -42,12 +50,15 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                 if (LOG.isTraceEnabled()) {
                         start = System.currentTimeMillis();
                 }
-                var problem = getProblem(doc, cancelIndicator);
-                if (problem == null) {
+                if (hasError(doc, cancelIndicator)) {
                         return null;
                 }
+                var problem = getProblem(doc);
+                if (problem == null) {
+                        return new SemanticsSuccessResult(List.of(), new JsonObject());
+                }
                 var worker = workerProvider.get();
-                worker.setProblem(problem,cancelIndicator);
+                worker.setProblem(problem, cancelIndicator);
                 var future = executorService.submit(worker);
                 SemanticsResult result = null;
                 try {
@@ -58,11 +69,19 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                         Thread.currentThread().interrupt();
                 } catch (ExecutionException e) {
                         operationCanceledManager.propagateAsErrorIfCancelException(e.getCause());
-                        throw new IllegalStateException(e);
+                        LOG.debug("Error while computing semantics", e);
+                        if (e.getCause() instanceof Error error) {
+                                throw error;
+                        }
+                        String message = e.getMessage();
+                        if (message == null) {
+                                message = "Partial interpretation error";
+                        }
+                        return new SemanticsInternalErrorResult(message);
                 } catch (TimeoutException e) {
                         future.cancel(true);
                         LOG.trace("Semantics service timeout", e);
-                        return new SemanticsErrorResult("Partial interpretation timed out");
+                        return new SemanticsInternalErrorResult("Partial interpretation timed out");
                 }
                 if (LOG.isTraceEnabled()) {
                         long end = System.currentTimeMillis();
@@ -72,17 +91,17 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                 return result;
         }
 
-        @Nullable
-        private Problem getProblem(IXtextWebDocument doc, CancelIndicator cancelIndicator) {
+        private boolean hasError(IXtextWebDocument doc, CancelIndicator cancelIndicator) {
                 if (!(doc instanceof PushWebDocument pushDoc)) {
                         throw new IllegalArgumentException("Unexpected IXtextWebDocument: " + doc);
                 }
                 var validationResult = pushDoc.getCachedServiceResult(validationService, cancelIndicator, true);
-                boolean hasError = validationResult.getIssues().stream()
+                return validationResult.getIssues().stream()
                                 .anyMatch(issue -> "error".equals(issue.getSeverity()));
-                if (hasError) {
-                        return null;
-                }
+        }
+
+        @Nullable
+        private Problem getProblem(IXtextWebDocument doc) {
                 var contents = doc.getResource().getContents();
                 if (contents.isEmpty()) {
                         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 25589260..43d0238c 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
@@ -8,13 +8,19 @@ package tools.refinery.language.web.semantics;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
 import com.google.inject.Inject;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.service.OperationCanceledManager;
 import org.eclipse.xtext.util.CancelIndicator;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.eclipse.xtext.validation.CheckType;
+import org.eclipse.xtext.validation.FeatureBasedDiagnostic;
+import org.eclipse.xtext.validation.IDiagnosticConverter;
+import org.eclipse.xtext.validation.Issue;
+import org.eclipse.xtext.web.server.validation.ValidationResult;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.semantics.model.ModelInitializer;
 import tools.refinery.language.semantics.model.SemanticsUtils;
+import tools.refinery.language.semantics.model.TracedException;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
@@ -22,17 +28,19 @@ import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.ReasoningStoreAdapter;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.viatra.runtime.CancellationToken;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.TreeMap;
 import java.util.concurrent.Callable;
 
 class SemanticsWorker implements Callable<SemanticsResult> {
-        private static final Logger LOG = LoggerFactory.getLogger(SemanticsWorker.class);
+        private static final String DIAGNOSTIC_ID = "tools.refinery.language.semantics.SemanticError";
 
         @Inject
         private SemanticsUtils semanticsUtils;
@@ -41,6 +49,9 @@ class SemanticsWorker implements Callable<SemanticsResult> {
         private OperationCanceledManager operationCanceledManager;
 
         @Inject
+        private IDiagnosticConverter diagnosticConverter;
+
+        @Inject
         private ModelInitializer initializer;
 
         private Problem problem;
@@ -71,15 +82,17 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                         cancellationToken.checkCancelled();
                         var store = builder.build();
                         cancellationToken.checkCancelled();
-                        var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                        var cancellableModelSeed = CancellableSeed.wrap(cancellationToken, modelSeed);
+                        var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(cancellableModelSeed);
                         cancellationToken.checkCancelled();
                         var partialInterpretation = getPartialInterpretation(initializer, model);
 
                         return new SemanticsSuccessResult(nodeTrace, partialInterpretation);
-                } catch (RuntimeException e) {
-                        LOG.debug("Error while computing semantics", e);
-                        var message = e.getMessage();
-                        return new SemanticsErrorResult(message == null ? "Partial interpretation error" : e.getMessage());
+                } catch (TracedException e) {
+                        return getTracedErrorResult(e.getSourceElement(), e.getMessage());
+                } catch (TranslationException e) {
+                        var sourceElement = initializer.getInverseTrace(e.getPartialSymbol());
+                        return getTracedErrorResult(sourceElement, e.getMessage());
                 }
         }
 
@@ -130,4 +143,19 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                 json.add(value.toString());
                 return json;
         }
+
+        private SemanticsResult getTracedErrorResult(EObject sourceElement, String message) {
+                if (sourceElement == null || !problem.eResource().equals(sourceElement.eResource())) {
+                        return new SemanticsInternalErrorResult(message);
+                }
+                var diagnostic = new FeatureBasedDiagnostic(Diagnostic.ERROR, message, sourceElement, null, 0,
+                                CheckType.EXPENSIVE, DIAGNOSTIC_ID);
+                var xtextIssues = new ArrayList<Issue>();
+                diagnosticConverter.convertValidatorDiagnostic(diagnostic, xtextIssues::add);
+                var issues = xtextIssues.stream()
+                                .map(issue -> new ValidationResult.Issue(issue.getMessage(), "error", issue.getLineNumber(),
+                                                issue.getColumn(), issue.getOffset(), issue.getLength()))
+                                .toList();
+                return new SemanticsIssuesResult(issues);
+        }
 }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java
index 1542c694..2d43fb26 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java
@@ -53,10 +53,9 @@ public class PushWebDocument extends XtextWebDocument {
         public <T extends IServiceResult> void precomputeServiceResult(AbstractCachedService<T> service, String serviceName,
                         CancelIndicator cancelIndicator, boolean logCacheMiss) {
                 var serviceClass = service.getClass();
-                var previousResult = precomputedServices.get(serviceClass);
                 var result = getCachedServiceResult(service, cancelIndicator, logCacheMiss);
                 precomputedServices.put(serviceClass, result);
-                if (result != null && !result.equals(previousResult)) {
+                if (result != null) {
                         notifyPrecomputationListeners(serviceName, result);
                 }
         }
diff --git a/subprojects/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java b/subprojects/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java
index 99ca5420..889a55cb 100644
--- a/subprojects/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java
+++ b/subprojects/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java
@@ -93,7 +93,7 @@ class ProblemWebSocketServletIntegrationTest {
                 clientSocket.waitForTestResult();
                 assertThat(clientSocket.getCloseStatusCode(), equalTo(StatusCode.NORMAL));
                 var responses = clientSocket.getResponses();
-                assertThat(responses, hasSize(7));
+                assertThat(responses, hasSize(8));
                 assertThat(responses.get(0), equalTo("{\"id\":\"foo\",\"response\":{\"stateId\":\"-80000000\"}}"));
                 assertThat(responses.get(1), startsWith(
                                 "{\"resource\":\"test.problem\",\"stateId\":\"-80000000\",\"service\":\"highlight\"," +
@@ -108,7 +108,10 @@ class ProblemWebSocketServletIntegrationTest {
                 assertThat(responses.get(5), startsWith(
                                 "{\"resource\":\"test.problem\",\"stateId\":\"-7fffffff\",\"service\":\"highlight\"," +
                                                 "\"push\":{\"regions\":["));
-                assertThat(responses.get(6), startsWith(
+                assertThat(responses.get(6), equalTo(
+                                "{\"resource\":\"test.problem\",\"stateId\":\"-7fffffff\",\"service\":\"validate\"," +
+                                                "\"push\":{\"issues\":[]}}"));
+                assertThat(responses.get(7), startsWith(
                                 "{\"resource\":\"test.problem\",\"stateId\":\"-7fffffff\",\"service\":\"semantics\"," +
                                                 "\"push\":{"));
         }
@@ -130,7 +133,7 @@ class ProblemWebSocketServletIntegrationTest {
                                                         "\"deltaOffset\":\"0\",\"deltaReplaceLength\":\"0\"}}",
                                         Callback.NOOP
                         );
-                        case 7 -> session.close();
+                        case 8 -> session.close();
                         }
                 }
         }
diff --git a/subprojects/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java b/subprojects/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java
index b7142506..22ce1b47 100644
--- a/subprojects/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java
+++ b/subprojects/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java
@@ -18,6 +18,7 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.ArgumentCaptor;
 import org.mockito.junit.jupiter.MockitoExtension;
+import tools.refinery.language.web.semantics.SemanticsService;
 import tools.refinery.language.web.tests.AwaitTerminationExecutorServiceProvider;
 import tools.refinery.language.web.tests.ProblemWebInjectorProvider;
 import tools.refinery.language.web.xtext.server.ResponseHandler;
@@ -59,11 +60,16 @@ class TransactionExecutorTest {
         @Inject
         private AwaitTerminationExecutorServiceProvider executorServices;
 
+        @Inject
+        private SemanticsService semanticsService;
+
         private TransactionExecutor transactionExecutor;
 
         @BeforeEach
         void beforeEach() {
                 transactionExecutor = new TransactionExecutor(new SimpleSession(), resourceServiceProviderRegistry);
+                // Manually re-create the semantics analysis thread pool if it was disposed by the previous test.
+                semanticsService.setExecutorServiceProvider(executorServices);
         }
 
         @Test
@@ -95,7 +101,7 @@ class TransactionExecutorTest {
                                                 "0")));
 
                 var captor = newCaptor();
-                verify(responseHandler, times(3)).onResponse(captor.capture());
+                verify(responseHandler, times(4)).onResponse(captor.capture());
                 var newStateId = getStateId("bar", captor.getAllValues().get(0));
                 assertHighlightingResponse(newStateId, captor.getAllValues().get(1));
         }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/InvalidQueryException.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/InvalidQueryException.java
new file mode 100644
index 00000000..c39277a0
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/InvalidQueryException.java
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query;
+
+public class InvalidQueryException extends RuntimeException {
+        public InvalidQueryException() {
+        }
+
+        public InvalidQueryException(String message) {
+                super(message);
+        }
+
+        public InvalidQueryException(String message, Throwable cause) {
+                super(message, cause);
+        }
+
+        public InvalidQueryException(Throwable cause) {
+                super(cause);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java
index 5d77b9aa..8800a155 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java
@@ -7,6 +7,7 @@ package tools.refinery.store.query.dnf;
 
 import org.jetbrains.annotations.NotNull;
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.literal.*;
 import tools.refinery.store.query.substitution.MapBasedSubstitution;
 import tools.refinery.store.query.substitution.StatelessSubstitution;
@@ -160,7 +161,7 @@ class ClausePostProcessor {
                                 // Inputs count as positive, because they are already bound when we evaluate literals.
                                 positiveVariables.add(variable);
                         } else if (!existentiallyQuantifiedVariables.contains(variable)) {
-                                throw new IllegalArgumentException("Unbound %s parameter %s"
+                                throw new InvalidQueryException("Unbound %s parameter %s"
                                                 .formatted(ParameterDirection.OUT, variable));
                         }
                 }
@@ -172,7 +173,7 @@ class ClausePostProcessor {
                         var representative = pair.getKey();
                         if (!positiveVariables.contains(representative)) {
                                 var variableSet = pair.getValue();
-                                throw new IllegalArgumentException("Variables %s were merged by equivalence but are not bound"
+                                throw new InvalidQueryException("Variables %s were merged by equivalence but are not bound"
                                                 .formatted(variableSet));
                         }
                 }
@@ -184,7 +185,7 @@ class ClausePostProcessor {
                         for (var variable : literal.getPrivateVariables(positiveVariables)) {
                                 var oldLiteral = negativeVariablesMap.put(variable, literal);
                                 if (oldLiteral != null) {
-                                        throw new IllegalArgumentException("Unbound variable %s appears in multiple literals %s and %s"
+                                        throw new InvalidQueryException("Unbound variable %s appears in multiple literals %s and %s"
                                                         .formatted(variable, oldLiteral, literal));
                                 }
                         }
@@ -206,7 +207,7 @@ class ClausePostProcessor {
                         variable.addToSortedLiterals();
                 }
                 if (!variableToLiteralInputMap.isEmpty()) {
-                        throw new IllegalArgumentException("Unbound input variables %s"
+                        throw new InvalidQueryException("Unbound input variables %s"
                                         .formatted(variableToLiteralInputMap.keySet()));
                 }
         }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java
index 55f1aae5..86a1b6b2 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.dnf;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.DnfEqualityChecker;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.SubstitutingLiteralEqualityHelper;
@@ -55,7 +56,7 @@ public final class Dnf implements Constraint {
                                                                                    FunctionalDependency<Variable> functionalDependency) {
                 for (var variable : toValidate) {
                         if (!parameterSet.contains(variable)) {
-                                throw new IllegalArgumentException(
+                                throw new InvalidQueryException(
                                                 "Variable %s of functional dependency %s does not appear in the parameter list %s"
                                                                 .formatted(variable, functionalDependency, symbolicParameters));
                         }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java
index 0538427f..0f9fd366 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java
@@ -5,10 +5,8 @@
  */
 package tools.refinery.store.query.dnf;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.dnf.callback.*;
-import tools.refinery.store.query.equality.DnfEqualityChecker;
-import tools.refinery.store.query.equality.SubstitutingLiteralEqualityHelper;
-import tools.refinery.store.query.equality.SubstitutingLiteralHashCodeHelper;
 import tools.refinery.store.query.literal.Literal;
 import tools.refinery.store.query.term.*;
 
@@ -100,7 +98,7 @@ public final class DnfBuilder {
         public DnfBuilder symbolicParameter(SymbolicParameter symbolicParameter) {
                 var variable = symbolicParameter.getVariable();
                 if (!parameterVariables.add(variable)) {
-                        throw new IllegalArgumentException("Variable %s is already on the parameter list %s"
+                        throw new InvalidQueryException("Variable %s is already on the parameter list %s"
                                         .formatted(variable, parameters));
                 }
                 parameters.add(symbolicParameter);
@@ -218,88 +216,10 @@ public final class DnfBuilder {
         }
 
         public Dnf build() {
-                var postProcessedClauses = postProcessClauses();
+                var postProcessor = new DnfPostProcessor(parameters, clauses);
+                var postProcessedClauses = postProcessor.postProcessClauses();
                 return new Dnf(name, Collections.unmodifiableList(parameters),
                                 Collections.unmodifiableList(functionalDependencies),
                                 Collections.unmodifiableList(postProcessedClauses));
         }
-
-        private List<DnfClause> postProcessClauses() {
-                var parameterInfoMap = getParameterInfoMap();
-                var postProcessedClauses = new LinkedHashSet<CanonicalClause>(clauses.size());
-                for (var literals : clauses) {
-                        var postProcessor = new ClausePostProcessor(parameterInfoMap, literals);
-                        var result = postProcessor.postProcessClause();
-                        if (result instanceof ClausePostProcessor.ClauseResult clauseResult) {
-                                postProcessedClauses.add(new CanonicalClause(clauseResult.clause()));
-                        } else if (result instanceof ClausePostProcessor.ConstantResult constantResult) {
-                                switch (constantResult) {
-                                case ALWAYS_TRUE -> {
-                                        var inputVariables = getInputVariables();
-                                        return List.of(new DnfClause(inputVariables, List.of()));
-                                }
-                                case ALWAYS_FALSE -> {
-                                        // Skip this clause because it can never match.
-                                }
-                                default -> throw new IllegalStateException("Unexpected ClausePostProcessor.ConstantResult: " +
-                                                constantResult);
-                                }
-                        } else {
-                                throw new IllegalStateException("Unexpected ClausePostProcessor.Result: " + result);
-                        }
-                }
-                return postProcessedClauses.stream().map(CanonicalClause::getDnfClause).toList();
-        }
-
-        private Map<Variable, ClausePostProcessor.ParameterInfo> getParameterInfoMap() {
-                var mutableParameterInfoMap = new LinkedHashMap<Variable, ClausePostProcessor.ParameterInfo>();
-                int arity = parameters.size();
-                for (int i = 0; i < arity; i++) {
-                        var parameter = parameters.get(i);
-                        mutableParameterInfoMap.put(parameter.getVariable(),
-                                        new ClausePostProcessor.ParameterInfo(parameter.getDirection(), i));
-                }
-                return Collections.unmodifiableMap(mutableParameterInfoMap);
-        }
-
-        private Set<Variable> getInputVariables() {
-                var inputParameters = new LinkedHashSet<Variable>();
-                for (var parameter : parameters) {
-                        if (parameter.getDirection() == ParameterDirection.IN) {
-                                inputParameters.add(parameter.getVariable());
-                        }
-                }
-                return Collections.unmodifiableSet(inputParameters);
-        }
-
-        private class CanonicalClause {
-                private final DnfClause dnfClause;
-
-                public CanonicalClause(DnfClause dnfClause) {
-                        this.dnfClause = dnfClause;
-                }
-
-                public DnfClause getDnfClause() {
-                        return dnfClause;
-                }
-
-                @Override
-                public boolean equals(Object obj) {
-                        if (this == obj) {
-                                return true;
-                        }
-                        if (obj == null || getClass() != obj.getClass()) {
-                                return false;
-                        }
-                        var otherCanonicalClause = (CanonicalClause) obj;
-                        var helper = new SubstitutingLiteralEqualityHelper(DnfEqualityChecker.DEFAULT, parameters, parameters);
-                        return dnfClause.equalsWithSubstitution(helper, otherCanonicalClause.dnfClause);
-                }
-
-                @Override
-                public int hashCode() {
-                        var helper = new SubstitutingLiteralHashCodeHelper(parameters);
-                        return dnfClause.hashCodeWithSubstitution(helper);
-                }
-        }
 }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfPostProcessor.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfPostProcessor.java
new file mode 100644
index 00000000..50236642
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfPostProcessor.java
@@ -0,0 +1,112 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.InvalidQueryException;
+import tools.refinery.store.query.equality.DnfEqualityChecker;
+import tools.refinery.store.query.equality.SubstitutingLiteralEqualityHelper;
+import tools.refinery.store.query.equality.SubstitutingLiteralHashCodeHelper;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.*;
+
+class DnfPostProcessor {
+        private final List<SymbolicParameter> parameters;
+        private final List<List<Literal>> clauses;
+
+        public DnfPostProcessor(List<SymbolicParameter> parameters, List<List<Literal>> clauses) {
+                this.parameters = parameters;
+                this.clauses = clauses;
+        }
+
+        public List<DnfClause> postProcessClauses() {
+                var parameterInfoMap = getParameterInfoMap();
+                var postProcessedClauses = new LinkedHashSet<CanonicalClause>(clauses.size());
+                int index = 0;
+                for (var literals : clauses) {
+                        var postProcessor = new ClausePostProcessor(parameterInfoMap, literals);
+                        ClausePostProcessor.Result result;
+                        try {
+                                result = postProcessor.postProcessClause();
+                        } catch (InvalidQueryException e) {
+                                throw new InvalidClauseException(index, e);
+                        }
+                        if (result instanceof ClausePostProcessor.ClauseResult clauseResult) {
+                                postProcessedClauses.add(new CanonicalClause(clauseResult.clause()));
+                        } else if (result instanceof ClausePostProcessor.ConstantResult constantResult) {
+                                switch (constantResult) {
+                                case ALWAYS_TRUE -> {
+                                        var inputVariables = getInputVariables();
+                                        return List.of(new DnfClause(inputVariables, List.of()));
+                                }
+                                case ALWAYS_FALSE -> {
+                                        // Skip this clause because it can never match.
+                                }
+                                default -> throw new IllegalStateException("Unexpected ClausePostProcessor.ConstantResult: " +
+                                                constantResult);
+                                }
+                        } else {
+                                throw new IllegalStateException("Unexpected ClausePostProcessor.Result: " + result);
+                        }
+                        index++;
+                }
+                return postProcessedClauses.stream().map(CanonicalClause::getDnfClause).toList();
+        }
+
+        private Map<Variable, ClausePostProcessor.ParameterInfo> getParameterInfoMap() {
+                var mutableParameterInfoMap = new LinkedHashMap<Variable, ClausePostProcessor.ParameterInfo>();
+                int arity = parameters.size();
+                for (int i = 0; i < arity; i++) {
+                        var parameter = parameters.get(i);
+                        mutableParameterInfoMap.put(parameter.getVariable(),
+                                        new ClausePostProcessor.ParameterInfo(parameter.getDirection(), i));
+                }
+                return Collections.unmodifiableMap(mutableParameterInfoMap);
+        }
+
+        private Set<Variable> getInputVariables() {
+                var inputParameters = new LinkedHashSet<Variable>();
+                for (var parameter : parameters) {
+                        if (parameter.getDirection() == ParameterDirection.IN) {
+                                inputParameters.add(parameter.getVariable());
+                        }
+                }
+                return Collections.unmodifiableSet(inputParameters);
+        }
+
+        private class CanonicalClause {
+                private final DnfClause dnfClause;
+
+                public CanonicalClause(DnfClause dnfClause) {
+                        this.dnfClause = dnfClause;
+                }
+
+                public DnfClause getDnfClause() {
+                        return dnfClause;
+                }
+
+                @Override
+                public boolean equals(Object obj) {
+                        if (this == obj) {
+                                return true;
+                        }
+                        if (obj == null || getClass() != obj.getClass()) {
+                                return false;
+                        }
+                        var otherCanonicalClause = (CanonicalClause) obj;
+                        var helper = new SubstitutingLiteralEqualityHelper(DnfEqualityChecker.DEFAULT, parameters, parameters);
+                        return dnfClause.equalsWithSubstitution(helper, otherCanonicalClause.dnfClause);
+                }
+
+                @Override
+                public int hashCode() {
+                        var helper = new SubstitutingLiteralHashCodeHelper(parameters);
+                        return dnfClause.hashCodeWithSubstitution(helper);
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java
index b00b2cb7..aef07ee3 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java
@@ -5,6 +5,8 @@
  */
 package tools.refinery.store.query.dnf;
 
+import tools.refinery.store.query.InvalidQueryException;
+
 import java.util.HashSet;
 import java.util.Set;
 
@@ -13,7 +15,7 @@ public record FunctionalDependency<T>(Set<T> forEach, Set<T> unique) {
                 var uniqueForEach = new HashSet<>(unique);
                 uniqueForEach.retainAll(forEach);
                 if (!uniqueForEach.isEmpty()) {
-                        throw new IllegalArgumentException("Variables %s appear on both sides of the functional dependency"
+                        throw new InvalidQueryException("Variables %s appear on both sides of the functional dependency"
                                         .formatted(uniqueForEach));
                 }
         }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java
index bf7651ad..225f6844 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.dnf;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.literal.CallPolarity;
 import tools.refinery.store.query.term.Aggregator;
 import tools.refinery.store.query.term.AssignedValue;
@@ -26,14 +27,14 @@ public final class FunctionalQuery<T> extends Query<T> {
                         var parameter = parameters.get(i);
                         var parameterType = parameter.tryGetType();
                         if (parameterType.isPresent()) {
-                                throw new IllegalArgumentException("Expected parameter %s of %s to be a node variable, got %s instead"
+                                throw new InvalidQueryException("Expected parameter %s of %s to be a node variable, got %s instead"
                                                 .formatted(parameter, dnf, parameterType.get().getName()));
                         }
                 }
                 var outputParameter = parameters.get(outputIndex);
                 var outputParameterType = outputParameter.tryGetType();
                 if (outputParameterType.isEmpty() || !outputParameterType.get().equals(type)) {
-                        throw new IllegalArgumentException("Expected parameter %s of %s to be %s, but got %s instead".formatted(
+                        throw new InvalidQueryException("Expected parameter %s of %s to be %s, but got %s instead".formatted(
                                         outputParameter, dnf, type, outputParameterType.map(Class::getName).orElse("node")));
                 }
                 this.type = type;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/InvalidClauseException.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/InvalidClauseException.java
new file mode 100644
index 00000000..747574b9
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/InvalidClauseException.java
@@ -0,0 +1,35 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.InvalidQueryException;
+
+public class InvalidClauseException extends InvalidQueryException {
+        private final int clauseIndex;
+
+        public InvalidClauseException(int clauseIndex) {
+                this.clauseIndex = clauseIndex;
+        }
+
+        public InvalidClauseException(int clauseIndex, String message) {
+                super(message);
+                this.clauseIndex = clauseIndex;
+        }
+
+        public InvalidClauseException(int clauseIndex, String message, Throwable cause) {
+                super(message, cause);
+                this.clauseIndex = clauseIndex;
+        }
+
+        public InvalidClauseException(int clauseIndex, Throwable cause) {
+                super(cause);
+                this.clauseIndex = clauseIndex;
+        }
+
+        public int getClauseIndex() {
+                return clauseIndex;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java
index 618fb595..98f71e11 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.dnf;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.literal.CallLiteral;
 import tools.refinery.store.query.literal.CallPolarity;
 import tools.refinery.store.query.term.AssignedValue;
@@ -19,7 +20,7 @@ public final class RelationalQuery extends Query<Boolean> {
                 for (var parameter : dnf.getSymbolicParameters()) {
                         var parameterType = parameter.tryGetType();
                         if (parameterType.isPresent()) {
-                                throw new IllegalArgumentException("Expected parameter %s of %s to be a node variable, got %s instead"
+                                throw new InvalidQueryException("Expected parameter %s of %s to be a node variable, got %s instead"
                                                 .formatted(parameter, dnf, parameterType.get().getName()));
                         }
                 }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java
index 3722f7f9..0e99d441 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.literal;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -27,7 +28,7 @@ public abstract class AbstractCallLiteral extends AbstractLiteral {
         protected AbstractCallLiteral(Constraint target, List<Variable> arguments) {
                 int arity = target.arity();
                 if (arguments.size() != arity) {
-                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(target.name(),
+                        throw new InvalidQueryException("%s needs %d arguments, but got %s".formatted(target.name(),
                                         target.arity(), arguments.size()));
                 }
                 this.target = target;
@@ -39,7 +40,7 @@ public abstract class AbstractCallLiteral extends AbstractLiteral {
                         var argument = arguments.get(i);
                         var parameter = parameters.get(i);
                         if (!parameter.isAssignable(argument)) {
-                                throw new IllegalArgumentException("Argument %d of %s is not assignable to parameter %s"
+                                throw new InvalidQueryException("Argument %d of %s is not assignable to parameter %s"
                                                 .formatted(i, target, parameter));
                         }
                         switch (parameter.getDirection()) {
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCountLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCountLiteral.java
index 75f4bd49..9bb572c0 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCountLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCountLiteral.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.literal;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.term.ConstantTerm;
@@ -26,11 +27,11 @@ public abstract class AbstractCountLiteral<T> extends AbstractCallLiteral {
                                                                    List<Variable> arguments) {
                 super(target, arguments);
                 if (!resultVariable.getType().equals(resultType)) {
-                        throw new IllegalArgumentException("Count result variable %s must be of type %s, got %s instead".formatted(
+                        throw new InvalidQueryException("Count result variable %s must be of type %s, got %s instead".formatted(
                                         resultVariable, resultType, resultVariable.getType().getName()));
                 }
                 if (arguments.contains(resultVariable)) {
-                        throw new IllegalArgumentException("Count result variable %s must not appear in the argument list"
+                        throw new InvalidQueryException("Count result variable %s must not appear in the argument list"
                                         .formatted(resultVariable));
                 }
                 this.resultType = resultType;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java
index a2f8e009..e3acfacc 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.literal;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -26,19 +27,19 @@ public class AggregationLiteral<R, T> extends AbstractCallLiteral {
                                                           DataVariable<T> inputVariable, Constraint target, List<Variable> arguments) {
                 super(target, arguments);
                 if (!inputVariable.getType().equals(aggregator.getInputType())) {
-                        throw new IllegalArgumentException("Input variable %s must of type %s, got %s instead".formatted(
+                        throw new InvalidQueryException("Input variable %s must of type %s, got %s instead".formatted(
                                         inputVariable, aggregator.getInputType().getName(), inputVariable.getType().getName()));
                 }
                 if (!getArgumentsOfDirection(ParameterDirection.OUT).contains(inputVariable)) {
-                        throw new IllegalArgumentException("Input variable %s must be bound with direction %s in the argument list"
+                        throw new InvalidQueryException("Input variable %s must be bound with direction %s in the argument list"
                                         .formatted(inputVariable, ParameterDirection.OUT));
                 }
                 if (!resultVariable.getType().equals(aggregator.getResultType())) {
-                        throw new IllegalArgumentException("Result variable %s must of type %s, got %s instead".formatted(
+                        throw new InvalidQueryException("Result variable %s must of type %s, got %s instead".formatted(
                                         resultVariable, aggregator.getResultType().getName(), resultVariable.getType().getName()));
                 }
                 if (arguments.contains(resultVariable)) {
-                        throw new IllegalArgumentException("Result variable %s must not appear in the argument list".formatted(
+                        throw new InvalidQueryException("Result variable %s must not appear in the argument list".formatted(
                                         resultVariable));
                 }
                 this.resultVariable = resultVariable;
@@ -66,7 +67,7 @@ public class AggregationLiteral<R, T> extends AbstractCallLiteral {
         @Override
         public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
                 if (positiveVariablesInClause.contains(inputVariable)) {
-                        throw new IllegalArgumentException("Aggregation variable %s must not be bound".formatted(inputVariable));
+                        throw new InvalidQueryException("Aggregation variable %s must not be bound".formatted(inputVariable));
                 }
                 return super.getInputVariables(positiveVariablesInClause);
         }
@@ -80,7 +81,7 @@ public class AggregationLiteral<R, T> extends AbstractCallLiteral {
                                 yield emptyValue == null ? BooleanLiteral.FALSE :
                                                 resultVariable.assign(new ConstantTerm<>(resultVariable.getType(), emptyValue));
                         }
-                        case ALWAYS_TRUE -> throw new IllegalArgumentException("Trying to aggregate over an infinite set");
+                        case ALWAYS_TRUE -> throw new InvalidQueryException("Trying to aggregate over an infinite set");
                         case NOT_REDUCIBLE -> this;
                 };
         }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java
index d8a4b494..dadf487f 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.literal;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -16,18 +17,20 @@ import java.util.Collections;
 import java.util.Objects;
 import java.util.Set;
 
+// {@link Object#equals(Object)} is implemented by {@link AbstractLiteral}.
+@SuppressWarnings("squid:S2160")
 public class AssignLiteral<T> extends AbstractLiteral {
         private final DataVariable<T> variable;
         private final Term<T> term;
 
         public AssignLiteral(DataVariable<T> variable, Term<T> term) {
                 if (!term.getType().equals(variable.getType())) {
-                        throw new IllegalArgumentException("Term %s must be of type %s, got %s instead".formatted(
+                        throw new InvalidQueryException("Term %s must be of type %s, got %s instead".formatted(
                                         term, variable.getType().getName(), term.getType().getName()));
                 }
                 var inputVariables = term.getInputVariables();
                 if (inputVariables.contains(variable)) {
-                        throw new IllegalArgumentException("Result variable %s must not appear in the term %s".formatted(
+                        throw new InvalidQueryException("Result variable %s must not appear in the term %s".formatted(
                                         variable, term));
                 }
                 this.variable = variable;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
index 1b05943d..2d0e4e97 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.literal;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -25,14 +26,14 @@ public final class CallLiteral extends AbstractCallLiteral implements CanNegate<
                 int arity = target.arity();
                 if (polarity.isTransitive()) {
                         if (arity != 2) {
-                                throw new IllegalArgumentException("Transitive closures can only take binary relations");
+                                throw new InvalidQueryException("Transitive closures can only take binary relations");
                         }
                         if (parameters.get(0).isDataVariable() || parameters.get(1).isDataVariable()) {
-                                throw new IllegalArgumentException("Transitive closures can only be computed over nodes");
+                                throw new InvalidQueryException("Transitive closures can only be computed over nodes");
                         }
                         if (parameters.get(0).getDirection() != ParameterDirection.OUT ||
                                         parameters.get(1).getDirection() != ParameterDirection.OUT) {
-                                throw new IllegalArgumentException("Transitive closures cannot take input parameters");
+                                throw new InvalidQueryException("Transitive closures cannot take input parameters");
                         }
                 }
                 this.polarity = polarity;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java
index ca70b0fd..716c7109 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java
@@ -5,6 +5,8 @@
  */
 package tools.refinery.store.query.literal;
 
+import tools.refinery.store.query.InvalidQueryException;
+
 public enum CallPolarity {
         POSITIVE(true, false),
         NEGATIVE(false, false),
@@ -31,7 +33,7 @@ public enum CallPolarity {
                 return switch (this) {
                         case POSITIVE -> NEGATIVE;
                         case NEGATIVE -> POSITIVE;
-                        case TRANSITIVE -> throw new IllegalArgumentException("Transitive polarity cannot be negated");
+                        case TRANSITIVE -> throw new InvalidQueryException("Transitive polarity cannot be negated");
                 };
         }
 }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CheckLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CheckLiteral.java
index 1271183a..dfedd2cb 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CheckLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CheckLiteral.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.literal;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -18,12 +19,14 @@ import java.util.Collections;
 import java.util.Objects;
 import java.util.Set;
 
+// {@link Object#equals(Object)} is implemented by {@link AbstractLiteral}.
+@SuppressWarnings("squid:S2160")
 public class CheckLiteral extends AbstractLiteral implements CanNegate<CheckLiteral> {
         private final Term<Boolean> term;
 
         public CheckLiteral(Term<Boolean> term) {
                 if (!term.getType().equals(Boolean.class)) {
-                        throw new IllegalArgumentException("Term %s must be of type %s, got %s instead".formatted(
+                        throw new InvalidQueryException("Term %s must be of type %s, got %s instead".formatted(
                                         term, Boolean.class.getName(), term.getType().getName()));
                 }
                 this.term = term;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
index 9a0c22d1..7343f709 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.literal;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -22,7 +23,7 @@ public final class EquivalenceLiteral extends AbstractLiteral implements CanNega
 
         public EquivalenceLiteral(boolean positive, Variable left, Variable right) {
                 if (!left.tryGetType().equals(right.tryGetType())) {
-                        throw new IllegalArgumentException("Variables %s and %s of different type cannot be equivalent"
+                        throw new InvalidQueryException("Variables %s and %s of different type cannot be equivalent"
                                         .formatted(left, right));
                 }
                 this.positive = positive;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java
index f6545f9f..f7323947 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.literal;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -32,14 +33,14 @@ public class RepresentativeElectionLiteral extends AbstractCallLiteral {
                 var parameters = target.getParameters();
                 int arity = target.arity();
                 if (arity != 2) {
-                        throw new IllegalArgumentException("SCCs can only take binary relations");
+                        throw new InvalidQueryException("SCCs can only take binary relations");
                 }
                 if (parameters.get(0).isDataVariable() || parameters.get(1).isDataVariable()) {
-                        throw new IllegalArgumentException("SCCs can only be computed over nodes");
+                        throw new InvalidQueryException("SCCs can only be computed over nodes");
                 }
                 if (parameters.get(0).getDirection() != ParameterDirection.OUT ||
                                 parameters.get(1).getDirection() != ParameterDirection.OUT) {
-                        throw new IllegalArgumentException("SCCs cannot take input parameters");
+                        throw new InvalidQueryException("SCCs cannot take input parameters");
                 }
         }
 
@@ -72,7 +73,7 @@ public class RepresentativeElectionLiteral extends AbstractCallLiteral {
                 var reduction = getTarget().getReduction();
                 return switch (reduction) {
                         case ALWAYS_FALSE -> BooleanLiteral.FALSE;
-                        case ALWAYS_TRUE -> throw new IllegalArgumentException(
+                        case ALWAYS_TRUE -> throw new InvalidQueryException(
                                         "Trying to elect representatives over an infinite set");
                         case NOT_REDUCIBLE -> this;
                 };
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java
index 4d88051b..3801bc11 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.term;
 
 import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 
 import java.util.Optional;
@@ -33,7 +34,7 @@ public abstract sealed class AnyDataVariable extends Variable implements AnyTerm
 
         @Override
         public NodeVariable asNodeVariable() {
-                throw new IllegalStateException("%s is a data variable".formatted(this));
+                throw new InvalidQueryException("%s is a data variable".formatted(this));
         }
 
         @Override
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java
index 09c86db6..cdbf592a 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.term;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -26,11 +27,11 @@ public abstract class BinaryTerm<R, T1, T2> extends AbstractTerm<R> {
         protected BinaryTerm(Class<R> type, Class<T1> leftType, Class<T2> rightType, Term<T1> left, Term<T2> right) {
                 super(type);
                 if (!left.getType().equals(leftType)) {
-                        throw new IllegalArgumentException("Expected left %s to be of type %s, got %s instead".formatted(
+                        throw new InvalidQueryException("Expected left %s to be of type %s, got %s instead".formatted(
                                         left, leftType.getName(), left.getType().getName()));
                 }
                 if (!right.getType().equals(rightType)) {
-                        throw new IllegalArgumentException("Expected right %s to be of type %s, got %s instead".formatted(
+                        throw new InvalidQueryException("Expected right %s to be of type %s, got %s instead".formatted(
                                         right, rightType.getName(), right.getType().getName()));
                 }
                 this.leftType = leftType;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java
index e722c84f..415ae286 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.term;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -21,7 +22,7 @@ public final class ConstantTerm<T> extends AbstractTerm<T> {
         public ConstantTerm(Class<T> type, T value) {
                 super(type);
                 if (value != null && !type.isInstance(value)) {
-                        throw new IllegalArgumentException("Value %s is not an instance of %s".formatted(value, type.getName()));
+                        throw new InvalidQueryException("Value %s is not an instance of %s".formatted(value, type.getName()));
                 }
                 this.value = value;
         }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java
index 9b62e545..2206b522 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.term;
 
 import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.literal.EquivalenceLiteral;
@@ -41,8 +42,8 @@ public final class DataVariable<T> extends AnyDataVariable implements Term<T> {
         @Override
         public <U> DataVariable<U> asDataVariable(Class<U> newType) {
                 if (!getType().equals(newType)) {
-                        throw new IllegalStateException("%s is not of type %s but of type %s".formatted(this, newType.getName(),
-                                        getType().getName()));
+                        throw new InvalidQueryException("%s is not of type %s but of type %s"
+                                        .formatted(this, newType.getName(), getType().getName()));
                 }
                 @SuppressWarnings("unchecked")
                 var result = (DataVariable<U>) this;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java
index 2f9c8bf1..53c32e20 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.term;
 
 import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.literal.ConstantLiteral;
 import tools.refinery.store.query.literal.EquivalenceLiteral;
 
@@ -48,7 +49,7 @@ public final class NodeVariable extends Variable {
 
         @Override
         public <T> DataVariable<T> asDataVariable(Class<T> type) {
-                throw new IllegalStateException("%s is a node variable".formatted(this));
+                throw new InvalidQueryException("%s is a node variable".formatted(this));
         }
 
         @Override
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java
index cd0739be..da83f3c3 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java
@@ -6,8 +6,8 @@
 package tools.refinery.store.query.term;
 
 public enum ParameterDirection {
-        OUT("@Out"),
-        IN("@In");
+        OUT("out"),
+        IN("in");
 
         private final String name;
 
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java
index 6451ea00..a464ece5 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.term;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
@@ -22,7 +23,7 @@ public abstract class UnaryTerm<R, T> extends AbstractTerm<R> {
         protected UnaryTerm(Class<R> type, Class<T> bodyType, Term<T> body) {
                 super(type);
                 if (!body.getType().equals(bodyType)) {
-                        throw new IllegalArgumentException("Expected body %s to be of type %s, got %s instead".formatted(body,
+                        throw new InvalidQueryException("Expected body %s to be of type %s, got %s instead".formatted(body,
                                         bodyType.getName(), body.getType().getName()));
                 }
                 this.bodyType = bodyType;
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java
index abae6e5c..924277ed 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.query.view;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.representation.Symbol;
 
@@ -66,7 +67,7 @@ public class FilteredView<T> extends TuplePreservingView<T> {
                         // The predicate doesn't need to handle the default value if it is null.
                 }
                 if (matchesDefaultValue) {
-                        throw new IllegalArgumentException("Tuples with default value %s cannot be enumerated in %s"
+                        throw new InvalidQueryException("Tuples with default value %s cannot be enumerated in %s"
                                         .formatted(defaultValue, getSymbol()));
                 }
         }
diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/DnfToDefinitionStringTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/DnfToDefinitionStringTest.java
index d75d7f17..12cfaa4e 100644
--- a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/DnfToDefinitionStringTest.java
+++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/DnfToDefinitionStringTest.java
@@ -50,7 +50,7 @@ class DnfToDefinitionStringTest {
                 var dnf = Dnf.builder("Example").parameter(p, ParameterDirection.IN).clause().build();
 
                 assertThat(dnf.toDefinitionString(), is("""
-                                pred Example(@In p) <->
+                                pred Example(in p) <->
                                     <empty>.
                                 """));
         }
@@ -73,7 +73,7 @@ class DnfToDefinitionStringTest {
                                 .build();
 
                 assertThat(dnf.toDefinitionString(), is("""
-                                pred Example(@In p) <->
+                                pred Example(in p) <->
                                     !(@RelationView("key") friend(p, q)).
                                 """));
         }
diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/TopologicalSortTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/TopologicalSortTest.java
index e22dbb21..854bd469 100644
--- a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/TopologicalSortTest.java
+++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/TopologicalSortTest.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.query.dnf;
 
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.term.NodeVariable;
 import tools.refinery.store.query.term.ParameterDirection;
 import tools.refinery.store.query.term.Variable;
@@ -80,7 +81,7 @@ class TopologicalSortTest {
                                                 example.call(r, t, q, s),
                                                 friendView.call(r, t)
                                 );
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidQueryException.class, builder::build);
         }
 
         @Test
@@ -93,7 +94,7 @@ class TopologicalSortTest {
                                                 example.call(p, q, r, s),
                                                 example.call(r, t, q, s)
                                 );
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidQueryException.class, builder::build);
         }
 
         @Test
@@ -107,6 +108,6 @@ class TopologicalSortTest {
                                                 example.call(r, t, q, s),
                                                 example.call(p, q, r, t)
                                 );
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidQueryException.class, builder::build);
         }
 }
diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java
index bfeaa447..fc3f5d48 100644
--- a/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java
+++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/dnf/VariableDirectionTest.java
@@ -48,7 +48,7 @@ class VariableDirectionTest {
         @MethodSource("clausesWithVariableInput")
         void unboundOutVariableTest(List<? extends Literal> clause) {
                 var builder = Dnf.builder().parameter(p, ParameterDirection.OUT).clause(clause);
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidClauseException.class, builder::build);
         }
 
         @ParameterizedTest
@@ -100,7 +100,7 @@ class VariableDirectionTest {
                 var clauseWithEquivalence = new ArrayList<Literal>(clause);
                 clauseWithEquivalence.add(r.isEquivalent(p));
                 var builder = Dnf.builder().clause(clauseWithEquivalence);
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidClauseException.class, builder::build);
         }
 
         static Stream<Arguments> clausesNotBindingVariable() {
@@ -118,7 +118,7 @@ class VariableDirectionTest {
         @MethodSource("literalsWithPrivateVariable")
         void unboundTwicePrivateVariableTest(Literal literal) {
                 var builder = Dnf.builder().clause(not(personView.call(p)), literal);
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidClauseException.class, builder::build);
         }
 
         @ParameterizedTest
@@ -126,7 +126,7 @@ class VariableDirectionTest {
         void unboundTwiceByEquivalencePrivateVariableTest(Literal literal) {
                 var r = Variable.of("r");
                 var builder = Dnf.builder().clause(not(personView.call(r)), r.isEquivalent(p), literal);
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidClauseException.class, builder::build);
         }
 
         static Stream<Arguments> literalsWithPrivateVariable() {
@@ -159,7 +159,7 @@ class VariableDirectionTest {
         @MethodSource("literalsWithRequiredVariableInput")
         void unboundPrivateVariableTest(Literal literal) {
                 var builder = Dnf.builder().clause(literal);
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidClauseException.class, builder::build);
         }
 
         @ParameterizedTest
diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/literal/AggregationLiteralTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/literal/AggregationLiteralTest.java
index 35910e08..ddd57e96 100644
--- a/subprojects/store-query/src/test/java/tools/refinery/store/query/literal/AggregationLiteralTest.java
+++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/literal/AggregationLiteralTest.java
@@ -7,15 +7,16 @@ package tools.refinery.store.query.literal;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.InvalidClauseException;
 import tools.refinery.store.query.term.*;
 
 import java.util.List;
 import java.util.Set;
 
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.*;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static tools.refinery.store.query.literal.Literals.not;
@@ -57,13 +58,13 @@ class AggregationLiteralTest {
         @Test
         void missingAggregationVariableTest() {
                 var aggregation = fakeConstraint.aggregateBy(y, INT_SUM, p, z);
-                assertThrows(IllegalArgumentException.class, () -> x.assign(aggregation));
+                assertThrows(InvalidQueryException.class, () -> x.assign(aggregation));
         }
 
         @Test
         void circularAggregationVariableTest() {
                 var aggregation = fakeConstraint.aggregateBy(x, INT_SUM, p, x);
-                assertThrows(IllegalArgumentException.class, () -> x.assign(aggregation));
+                assertThrows(InvalidQueryException.class, () -> x.assign(aggregation));
         }
 
         @Test
@@ -73,7 +74,7 @@ class AggregationLiteralTest {
                                                 not(fakeConstraint.call(p, y)),
                                                 x.assign(fakeConstraint.aggregateBy(y, INT_SUM, p, y))
                                 );
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidClauseException.class, builder::build);
         }
 
         @Test
@@ -83,6 +84,6 @@ class AggregationLiteralTest {
                                                 y.assign(constant(27)),
                                                 x.assign(fakeConstraint.aggregateBy(y, INT_SUM, p, y))
                                 );
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(InvalidClauseException.class, builder::build);
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
index 6e0e91e1..2235a95d 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.reasoning.literal;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.literal.Reduction;
 import tools.refinery.store.query.term.Parameter;
@@ -17,7 +18,7 @@ public record ModalConstraint(Modality modality, Concreteness concreteness, Cons
                 implements Constraint {
         public ModalConstraint {
                 if (constraint instanceof AnySymbolView || constraint instanceof ModalConstraint) {
-                        throw new IllegalArgumentException("Already concrete constraints cannot be abstracted");
+                        throw new InvalidQueryException("Already concrete constraints cannot be abstracted");
                 }
         }
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
index 2c879397..2614c26e 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.reasoning.literal;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.literal.CallLiteral;
 
 public final class PartialLiterals {
@@ -31,7 +32,7 @@ public final class PartialLiterals {
         public static CallLiteral addModality(CallLiteral literal, Modality modality, Concreteness concreteness) {
                 var target = literal.getTarget();
                 if (target instanceof ModalConstraint) {
-                        throw new IllegalArgumentException("Literal %s already has modality".formatted(literal));
+                        throw new InvalidQueryException("Literal %s already has modality".formatted(literal));
                 }
                 var polarity = literal.getPolarity();
                 var modalTarget = new ModalConstraint(modality.commute(polarity), concreteness, target);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java
index 28e6258e..e6b3eaf9 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java
@@ -13,6 +13,7 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.Consumer;
 
 public class ModelSeed {
@@ -43,6 +44,10 @@ public class ModelSeed {
                 return seeds.containsKey(symbol);
         }
 
+        public Set<AnyPartialSymbol> getSeededSymbols() {
+                return Collections.unmodifiableSet(seeds.keySet());
+        }
+
         public <A> Cursor<Tuple, A> getCursor(PartialSymbol<A, ?> partialSymbol, A defaultValue) {
                 return getSeed(partialSymbol).getCursor(defaultValue, nodeCount);
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationException.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationException.java
new file mode 100644
index 00000000..edb886ba
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationException.java
@@ -0,0 +1,35 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator;
+
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+
+public class TranslationException extends RuntimeException {
+        private final transient AnyPartialSymbol partialSymbol;
+
+        public TranslationException(AnyPartialSymbol partialSymbol) {
+                this.partialSymbol = partialSymbol;
+        }
+
+        public TranslationException(AnyPartialSymbol partialSymbol, String message) {
+                super(message);
+                this.partialSymbol = partialSymbol;
+        }
+
+        public TranslationException(AnyPartialSymbol partialSymbol, String message, Throwable cause) {
+                super(message, cause);
+                this.partialSymbol = partialSymbol;
+        }
+
+        public TranslationException(AnyPartialSymbol partialSymbol, Throwable cause) {
+                super(cause);
+                this.partialSymbol = partialSymbol;
+        }
+
+        public AnyPartialSymbol getPartialSymbol() {
+                return partialSymbol;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentInfo.java
index 1087e54d..e3457fa7 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentInfo.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentInfo.java
@@ -6,17 +6,18 @@
 package tools.refinery.store.reasoning.translator.containment;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
 
 public record ContainmentInfo(PartialRelation sourceType, Multiplicity multiplicity,
                                                           PartialRelation targetType) {
         public ContainmentInfo {
                 if (sourceType.arity() != 1) {
-                        throw new IllegalArgumentException("Expected source type %s to be of arity 1, got %d instead"
-                                        .formatted(sourceType, sourceType.arity()));
+                        throw new TranslationException(sourceType, "Expected source type %s to be of arity 1, got %d instead"
+                                                        .formatted(sourceType, sourceType.arity()));
                 }
                 if (targetType.arity() != 1) {
-                        throw new IllegalArgumentException("Expected target type %s to be of arity 1, got %d instead"
+                        throw new TranslationException(targetType, "Expected target type %s to be of arity 1, got %d instead"
                                         .formatted(targetType, targetType.arity()));
                 }
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java
index cc43bce6..a21da3d4 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.reasoning.translator.metamodel;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
 import tools.refinery.store.reasoning.translator.typehierarchy.TypeHierarchyBuilder;
 
@@ -23,7 +24,7 @@ public class ContainedTypeHierarchyBuilder extends TypeHierarchyBuilder {
                 for (var containedType : containedTypes) {
                         var currentInfo = typeInfoMap.get(containedType);
                         if (currentInfo == null) {
-                                throw new IllegalArgumentException("Invalid contained type: " + containedType);
+                                throw new TranslationException(containedType, "Invalid contained type: " + containedType);
                         }
                         var newInfo = currentInfo.addSupertype(ContainmentHierarchyTranslator.CONTAINED_SYMBOL);
                         typeInfoMap.put(containedType, newInfo);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
index d0732edc..ad0288ed 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.reasoning.translator.metamodel;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
 import tools.refinery.store.reasoning.translator.containment.ContainmentInfo;
 import tools.refinery.store.reasoning.translator.crossreference.DirectedCrossReferenceInfo;
@@ -13,7 +14,6 @@ import tools.refinery.store.reasoning.translator.crossreference.UndirectedCrossR
 import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
 import tools.refinery.store.reasoning.translator.multiplicity.UnconstrainedMultiplicity;
 import tools.refinery.store.reasoning.translator.typehierarchy.TypeInfo;
-import tools.refinery.store.representation.cardinality.CardinalityIntervals;
 
 import java.util.*;
 
@@ -70,12 +70,13 @@ public class MetamodelBuilder {
 
         public MetamodelBuilder reference(PartialRelation linkType, ReferenceInfo info) {
                 if (linkType.arity() != 2) {
-                        throw new IllegalArgumentException("Only references of arity 2 are supported, got %s with %d instead"
-                                        .formatted(linkType, linkType.arity()));
+                        throw new TranslationException(linkType,
+                                        "Only references of arity 2 are supported, got %s with %d instead".formatted(
+                                                        linkType, linkType.arity()));
                 }
                 var putResult = referenceInfoMap.put(linkType, info);
                 if (putResult != null && !putResult.equals(info)) {
-                        throw new IllegalArgumentException("Duplicate reference info for partial relation: " + linkType);
+                        throw new TranslationException(linkType, "Duplicate reference info for partial relation: " + linkType);
                 }
                 return this;
         }
@@ -154,11 +155,11 @@ public class MetamodelBuilder {
                 var sourceType = info.sourceType();
                 var targetType = info.targetType();
                 if (typeHierarchyBuilder.isInvalidType(sourceType)) {
-                        throw new IllegalArgumentException("Source type %s of %s is not in type hierarchy"
+                        throw new TranslationException(linkType, "Source type %s of %s is not in type hierarchy"
                                         .formatted(sourceType, linkType));
                 }
                 if (typeHierarchyBuilder.isInvalidType(targetType)) {
-                        throw new IllegalArgumentException("Target type %s of %s is not in type hierarchy"
+                        throw new TranslationException(linkType, "Target type %s of %s is not in type hierarchy"
                                         .formatted(targetType, linkType));
                 }
                 var opposite = info.opposite();
@@ -173,8 +174,9 @@ public class MetamodelBuilder {
                         }
                         if (opposite.equals(linkType)) {
                                 if (!sourceType.equals(targetType)) {
-                                        throw new IllegalArgumentException("Target %s of undirected reference %s differs from source %s"
-                                                        .formatted(targetType, linkType, sourceType));
+                                        throw new TranslationException(linkType,
+                                                        "Target %s of undirected reference %s differs from source %s".formatted(
+                                                                        targetType, linkType, sourceType));
                                 }
                                 undirectedCrossReferences.put(linkType, new UndirectedCrossReferenceInfo(sourceType,
                                                 info.multiplicity()));
@@ -183,8 +185,8 @@ public class MetamodelBuilder {
                         oppositeReferences.put(opposite, linkType);
                 }
                 if (info.containment()) {
-                        if (targetMultiplicity.multiplicity().meet(CardinalityIntervals.ONE).isEmpty()) {
-                                throw new IllegalArgumentException("Invalid opposite %s with multiplicity %s of containment %s"
+                        if (!UnconstrainedMultiplicity.INSTANCE.equals(targetMultiplicity)) {
+                                throw new TranslationException(opposite, "Invalid opposite %s with multiplicity %s of containment %s"
                                                 .formatted(opposite, targetMultiplicity, linkType));
                         }
                         containedTypes.add(targetType);
@@ -200,23 +202,23 @@ public class MetamodelBuilder {
                 var sourceType = info.sourceType();
                 var targetType = info.targetType();
                 if (oppositeInfo == null) {
-                        throw new IllegalArgumentException("Opposite %s of %s is not defined"
+                        throw new TranslationException(linkType, "Opposite %s of %s is not defined"
                                         .formatted(opposite, linkType));
                 }
                 if (!linkType.equals(oppositeInfo.opposite())) {
-                        throw new IllegalArgumentException("Expected %s to have opposite %s, got %s instead"
+                        throw new TranslationException(opposite, "Expected %s to have opposite %s, got %s instead"
                                         .formatted(opposite, linkType, oppositeInfo.opposite()));
                 }
                 if (!targetType.equals(oppositeInfo.sourceType())) {
-                        throw new IllegalArgumentException("Expected %s to have source type %s, got %s instead"
+                        throw new TranslationException(linkType, "Expected %s to have source type %s, got %s instead"
                                         .formatted(opposite, targetType, oppositeInfo.sourceType()));
                 }
                 if (!sourceType.equals(oppositeInfo.targetType())) {
-                        throw new IllegalArgumentException("Expected %s to have target type %s, got %s instead"
+                        throw new TranslationException(linkType, "Expected %s to have target type %s, got %s instead"
                                         .formatted(opposite, sourceType, oppositeInfo.targetType()));
                 }
                 if (oppositeInfo.containment() && info.containment()) {
-                        throw new IllegalArgumentException("Opposite %s of containment %s cannot be containment"
+                        throw new TranslationException(opposite, "Opposite %s of containment %s cannot be containment"
                                         .formatted(opposite, linkType));
                 }
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectInitializer.java
index fb84631d..f11ab46b 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectInitializer.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectInitializer.java
@@ -10,6 +10,7 @@ import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
 import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.representation.cardinality.CardinalityInterval;
@@ -37,7 +38,8 @@ class MultiObjectInitializer implements PartialModelInitializer {
                 for (int i = 0; i < intervals.length; i++) {
                         var interval = intervals[i];
                         if (interval.isEmpty()) {
-                                throw new IllegalArgumentException("Inconsistent existence or equality for node " + i);
+                                throw new TranslationException(ReasoningAdapter.EXISTS_SYMBOL,
+                                                "Inconsistent existence or equality for node " + i);
                         }
                         var uniqueInterval = uniqueTable.computeIfAbsent(intervals[i], Function.identity());
                         countInterpretation.put(Tuple.of(i), uniqueInterval);
@@ -58,9 +60,10 @@ class MultiObjectInitializer implements PartialModelInitializer {
                 } else {
                         Arrays.fill(intervals, CardinalityIntervals.SET);
                         if (!modelSeed.containsSeed(ReasoningAdapter.EXISTS_SYMBOL) ||
-                                !modelSeed.containsSeed(ReasoningAdapter.EQUALS_SYMBOL)) {
-                                throw new IllegalArgumentException("Seed for %s and %s is required if there is no seed for %s"
-                                                .formatted(ReasoningAdapter.EXISTS_SYMBOL, ReasoningAdapter.EQUALS_SYMBOL,
+                                        !modelSeed.containsSeed(ReasoningAdapter.EQUALS_SYMBOL)) {
+                                throw new TranslationException(MultiObjectTranslator.COUNT_SYMBOL,
+                                                "Seed for %s and %s is required if there is no seed for %s".formatted(
+                                                                ReasoningAdapter.EXISTS_SYMBOL, ReasoningAdapter.EQUALS_SYMBOL,
                                                                 MultiObjectTranslator.COUNT_SYMBOL));
                         }
                 }
@@ -78,9 +81,10 @@ class MultiObjectInitializer implements PartialModelInitializer {
                         switch (cursor.getValue()) {
                         case TRUE -> intervals[i] = intervals[i].meet(CardinalityIntervals.SOME);
                         case FALSE -> intervals[i] = intervals[i].meet(CardinalityIntervals.NONE);
-                        case ERROR -> throw new IllegalArgumentException("Inconsistent existence for node " + i);
-                        default -> throw new IllegalArgumentException("Invalid existence truth value %s for node %d"
-                                        .formatted(cursor.getValue(), i));
+                        case ERROR -> throw new TranslationException(ReasoningAdapter.EXISTS_SYMBOL,
+                                        "Inconsistent existence for node " + i);
+                        default -> throw new TranslationException(ReasoningAdapter.EXISTS_SYMBOL,
+                                        "Invalid existence truth value %s for node %d".formatted(cursor.getValue(), i));
                         }
                 }
         }
@@ -96,8 +100,8 @@ class MultiObjectInitializer implements PartialModelInitializer {
                         int i = key.get(0);
                         int otherIndex = key.get(1);
                         if (i != otherIndex) {
-                                throw new IllegalArgumentException("Off-diagonal equivalence (%d, %d) is not permitted"
-                                                .formatted(i, otherIndex));
+                                throw new TranslationException(ReasoningAdapter.EQUALS_SYMBOL,
+                                                "Off-diagonal equivalence (%d, %d) is not permitted".formatted(i, otherIndex));
                         }
                         checkNodeId(intervals, i);
                         switch (cursor.getValue()) {
@@ -105,14 +109,15 @@ class MultiObjectInitializer implements PartialModelInitializer {
                         case UNKNOWN -> {
                                 // Nothing do to, {@code intervals} is initialized with unknown equality.
                         }
-                        case ERROR -> throw new IllegalArgumentException("Inconsistent equality for node " + i);
-                        default -> throw new IllegalArgumentException("Invalid equality truth value %s for node %d"
-                                        .formatted(cursor.getValue(), i));
+                        case ERROR -> throw new TranslationException(ReasoningAdapter.EQUALS_SYMBOL,
+                                        "Inconsistent equality for node " + i);
+                        default -> throw new TranslationException(ReasoningAdapter.EQUALS_SYMBOL,
+                                        "Invalid equality truth value %s for node %d".formatted(cursor.getValue(), i));
                         }
                 }
                 for (int i = 0; i < intervals.length; i++) {
                         if (seed.get(Tuple.of(i, i)) == TruthValue.FALSE) {
-                                throw new IllegalArgumentException("Inconsistent equality for node " + i);
+                                throw new TranslationException(ReasoningAdapter.EQUALS_SYMBOL, "Inconsistent equality for node " + i);
                         }
                 }
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/ConstrainedMultiplicity.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/ConstrainedMultiplicity.java
index e441e41e..9db9cc96 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/ConstrainedMultiplicity.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/ConstrainedMultiplicity.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.reasoning.translator.multiplicity;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.representation.cardinality.CardinalityInterval;
 import tools.refinery.store.representation.cardinality.CardinalityIntervals;
 import tools.refinery.store.representation.cardinality.NonEmptyCardinalityInterval;
@@ -14,17 +15,17 @@ public record ConstrainedMultiplicity(NonEmptyCardinalityInterval multiplicity,
                 implements Multiplicity {
         public ConstrainedMultiplicity {
                 if (multiplicity.equals(CardinalityIntervals.SET)) {
-                        throw new IllegalArgumentException("Expected a constrained cardinality interval");
+                        throw new TranslationException(errorSymbol, "Expected a constrained cardinality interval");
                 }
                 if (errorSymbol.arity() != 1) {
-                        throw new IllegalArgumentException("Expected error symbol %s to have arity 1, got %d instead"
+                        throw new TranslationException(errorSymbol, "Expected error symbol %s to have arity 1, got %d instead"
                                         .formatted(errorSymbol, errorSymbol.arity()));
                 }
         }
 
         public static ConstrainedMultiplicity of(CardinalityInterval multiplicity, PartialRelation errorSymbol) {
                 if (!(multiplicity instanceof NonEmptyCardinalityInterval nonEmptyCardinalityInterval)) {
-                        throw new IllegalArgumentException("Inconsistent multiplicity");
+                        throw new TranslationException(errorSymbol, "Inconsistent multiplicity");
                 }
                 return new ConstrainedMultiplicity(nonEmptyCardinalityInterval, errorSymbol);
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java
index 522d8455..c5e5e83e 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java
@@ -14,6 +14,7 @@ import tools.refinery.store.reasoning.lifting.DnfLifter;
 import tools.refinery.store.reasoning.literal.*;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.representation.cardinality.FiniteUpperCardinality;
 import tools.refinery.store.representation.cardinality.UpperCardinalities;
 import tools.refinery.store.representation.cardinality.UpperCardinality;
@@ -36,11 +37,11 @@ public class InvalidMultiplicityErrorTranslator implements ModelStoreConfigurati
         public InvalidMultiplicityErrorTranslator(PartialRelation nodeType, PartialRelation linkType,
                                                                                           boolean inverse, Multiplicity multiplicity) {
                 if (nodeType.arity() != 1) {
-                        throw new IllegalArgumentException("Node type must be of arity 1, got %s with arity %d instead"
+                        throw new TranslationException(linkType, "Node type must be of arity 1, got %s with arity %d instead"
                                         .formatted(nodeType, nodeType.arity()));
                 }
                 if (linkType.arity() != 2) {
-                        throw new IllegalArgumentException("Link type must be of arity 2, got %s with arity %d instead"
+                        throw new TranslationException(linkType, "Link type must be of arity 2, got %s with arity %d instead"
                                         .formatted(linkType, linkType.arity()));
                 }
                 this.nodeType = nodeType;
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRelationTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRelationTranslator.java
index b25b9d7d..6e15a628 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRelationTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRelationTranslator.java
@@ -17,6 +17,7 @@ import tools.refinery.store.reasoning.literal.Modality;
 import tools.refinery.store.reasoning.refinement.RefinementBasedInitializer;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.TranslationException;
 
 import java.util.List;
 import java.util.Set;
@@ -26,6 +27,16 @@ public class OppositeRelationTranslator implements ModelStoreConfiguration, Part
         private final PartialRelation opposite;
 
         public OppositeRelationTranslator(PartialRelation linkType, PartialRelation opposite) {
+                if (linkType.arity() != 2) {
+                        throw new TranslationException(linkType,
+                                        "Expected relation with opposite %s to have arity 2, got %d instead"
+                                                        .formatted(linkType, linkType.arity()));
+                }
+                if (opposite.arity() != 2) {
+                        throw new TranslationException(linkType,
+                                        "Expected opposite %s of %s to have arity 2, got %d instead"
+                                                        .formatted(opposite, linkType, opposite.arity()));
+                }
                 this.linkType = linkType;
                 this.opposite = opposite;
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java
index ee022f2d..16745da1 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java
@@ -17,6 +17,7 @@ import tools.refinery.store.query.view.MayView;
 import tools.refinery.store.query.view.MustView;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 
@@ -33,11 +34,11 @@ public class PredicateTranslator implements ModelStoreConfiguration {
         public PredicateTranslator(PartialRelation relation, RelationalQuery query, boolean mutable,
                                                            TruthValue defaultValue) {
                 if (relation.arity() != query.arity()) {
-                        throw new IllegalArgumentException("Expected arity %d query for partial relation %s, got %d instead"
+                        throw new TranslationException(relation, "Expected arity %d query for partial relation %s, got %d instead"
                                         .formatted(relation.arity(), relation, query.arity()));
                 }
                 if (defaultValue.must()) {
-                        throw new IllegalArgumentException("Default value must be UNKNOWN or FALSE");
+                        throw new TranslationException(relation, "Default value must be UNKNOWN or FALSE");
                 }
                 this.relation = relation;
                 this.query = query;
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java
index 35ec54ad..3f918c97 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.reasoning.translator.typehierarchy;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 
 import java.util.*;
 
@@ -81,8 +82,9 @@ public class TypeHierarchy {
                                 for (var supertype : allSupertypes) {
                                         var supertypeInfo = extendedTypeInfoMap.get(supertype);
                                         if (supertypeInfo == null) {
-                                                throw new IllegalArgumentException("Supertype %s of %s is missing from the type hierarchy"
-                                                                .formatted(supertype, extendedTypeInfo.getType()));
+                                                throw new TranslationException(extendedTypeInfo.getType(),
+                                                                "Supertype %s of %s is missing from the type hierarchy"
+                                                                                .formatted(supertype, extendedTypeInfo.getType()));
                                         }
                                         found.addAll(supertypeInfo.getAllSupertypes());
                                 }
@@ -101,7 +103,7 @@ public class TypeHierarchy {
                         }
                         for (var supertype : extendedTypeInfo.getAllSupertypes()) {
                                 if (type.equals(supertype)) {
-                                        throw new IllegalArgumentException("%s cannot be a supertype of itself".formatted(type));
+                                        throw new TranslationException(type, "%s cannot be a supertype of itself".formatted(type));
                                 }
                                 var supertypeInfo = extendedTypeInfoMap.get(supertype);
                                 supertypeInfo.getAllSubtypes().add(type);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyBuilder.java
index 36efb878..ce8fda05 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyBuilder.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.reasoning.translator.typehierarchy;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 
 import java.util.*;
 
@@ -18,12 +19,14 @@ public class TypeHierarchyBuilder {
 
         public TypeHierarchyBuilder type(PartialRelation partialRelation, TypeInfo typeInfo) {
                 if (partialRelation.arity() != 1) {
-                        throw new IllegalArgumentException("Only types of arity 1 are supported, got %s with %d instead"
-                                        .formatted(partialRelation, partialRelation.arity()));
+                        throw new TranslationException(partialRelation,
+                                        "Only types of arity 1 are supported, got %s with %d instead"
+                                                        .formatted(partialRelation, partialRelation.arity()));
                 }
                 var putResult = typeInfoMap.put(partialRelation, typeInfo);
                 if (putResult != null && !putResult.equals(typeInfo)) {
-                        throw new IllegalArgumentException("Duplicate type info for partial relation: " + partialRelation);
+                        throw new TranslationException(partialRelation,
+                                        "Duplicate type info for partial relation: " + partialRelation);
                 }
                 return this;
         }
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilderTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilderTest.java
index 115ba8cd..0f1a1006 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilderTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilderTest.java
@@ -7,6 +7,7 @@ package tools.refinery.store.reasoning.translator.metamodel;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
 import tools.refinery.store.representation.cardinality.CardinalityIntervals;
 
@@ -26,7 +27,7 @@ class MetamodelBuilderTest {
                                 .reference(courses, university, course, location)
                                 .reference(location, course, university);
 
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(TranslationException.class, builder::build);
         }
 
         @Test
@@ -37,7 +38,7 @@ class MetamodelBuilderTest {
                                 .reference(courses, university, course, location)
                                 .reference(location, course, course, courses);
 
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(TranslationException.class, builder::build);
         }
 
         @Test
@@ -52,6 +53,6 @@ class MetamodelBuilderTest {
                                                 ConstrainedMultiplicity.of(CardinalityIntervals.atLeast(2), invalidMultiplicity),
                                                 university,     courses);
 
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(TranslationException.class, builder::build);
         }
 }
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTest.java
index 9fbf2334..931c62dd 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTest.java
@@ -8,6 +8,7 @@ package tools.refinery.store.reasoning.translator.typehierarchy;
 import org.hamcrest.Matchers;
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.representation.TruthValue;
 
 import java.util.Set;
@@ -200,7 +201,7 @@ class TypeHierarchyTest {
                                 .type(c1, c2)
                                 .type(c2, c1);
 
-                assertThrows(IllegalArgumentException.class, builder::build);
+                assertThrows(TranslationException.class, builder::build);
         }
 
         @Test