feat: improve semantics error reporting

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

30 files changed, 261 insertions, 142 deletions

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);
         }
 }