factbag 0.0.0-alpha.0

package/dist/core/query/index.js

@@ -0,0 +1,1947 @@
+import {
+  isFormula
+} from "../chunk-YF4PP42K.js";
+import {
+  PrimitiveArithmeticProgrammerError,
+  UnconstructiveRecursionProgrammerError,
+  UnsafeUnboundVariableProgrammerError
+} from "../chunk-X3LSDJL4.js";
+import {
+  assertGroundAtom,
+  atomEquals,
+  fieldEquals,
+  fieldIdentityToken,
+  isAtomForPredicate,
+  isAtomLike,
+  isGroundAtom
+} from "../chunk-4IP7CXNV.js";
+import {
+  AssertionError,
+  Var,
+  assert,
+  isVar
+} from "../chunk-UVOCOH2I.js";
+
+// src/solver/query-validation/utils.ts
+function ruleEdges(rule) {
+  const headPredicate = rule.head.atom.predicate;
+  const headBindings = variablesIn(rule.head.atom);
+  const edges = [];
+  collectBodyEdges(rule.body, headPredicate, new Set(headBindings), edges);
+  return edges;
+}
+function reachablePredicates(start, edges) {
+  const reachable = /* @__PURE__ */ new Set([start]);
+  const stack = [start];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const edge of edges) {
+      if (edge.from !== current || reachable.has(edge.to)) {
+        continue;
+      }
+      reachable.add(edge.to);
+      stack.push(edge.to);
+    }
+  }
+  return reachable;
+}
+function isNegativeLiteral(value) {
+  return typeof value === "object" && value !== null && "sign" in value && value.sign === "-" && "atom" in value && isAtomLike(value.atom);
+}
+function isAggregateFormula(value) {
+  return isFormula(value) && (value.kind === "sum" || value.kind === "count");
+}
+function isCompleteWhenOption(value) {
+  return typeof value === "object" && value !== null && "completeWhen" in value;
+}
+function isPrimitiveFormula(value) {
+  return isFormula(value) && ["add", "sub", "mul", "div", "eq", "neq", "lt", "lte", "gt", "gte"].includes(value.kind);
+}
+function bindVariables(value, bound) {
+  for (const variable of variablesIn(value)) {
+    bound.add(variable);
+  }
+}
+function hasUnboundVariable(value, bound) {
+  return variablesIn(value).some((variable) => !bound.has(variable));
+}
+function uniqueVariables(variables) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const variable of variables) {
+    if (!seen.has(variable)) {
+      seen.add(variable);
+      unique.push(variable);
+    }
+  }
+  return unique;
+}
+function variablesIn(value) {
+  if (isVar(value)) {
+    return [value];
+  }
+  if (typeof value !== "object" || value === null) {
+    return [];
+  }
+  if (value instanceof Date) {
+    return [];
+  }
+  return Object.values(value).flatMap(variablesIn);
+}
+function collectBodyEdges(body, headPredicate, bound, edges) {
+  if (isAtomLike(body)) {
+    edges.push({ from: headPredicate, to: body.predicate, kind: "positive" });
+    bindVariables(body, bound);
+    return;
+  }
+  if (isNegativeLiteral(body)) {
+    edges.push({
+      from: headPredicate,
+      to: body.atom.predicate,
+      kind: body.atom.predicate.world === "closed" ? "closed-world-not" : "explicit-not"
+    });
+    bindVariables(body.atom, bound);
+    return;
+  }
+  if (isFormula(body, "and")) {
+    for (const arg of body.args) {
+      collectBodyEdges(arg, headPredicate, bound, edges);
+    }
+    return;
+  }
+  if (isFormula(body, "or") || isFormula(body, "exists")) {
+    for (const arg of body.args) {
+      collectBodyEdges(arg, headPredicate, new Set(bound), edges);
+    }
+    return;
+  }
+  if (isFormula(body, "letIn")) {
+    const [variable, value, nextBody] = body.args;
+    if (isAggregateFormula(value)) {
+      collectAggregateEdges(value, headPredicate, bound, edges);
+    } else if (hasUnboundVariable(value, bound)) {
+      edges.push({ from: headPredicate, to: headPredicate, kind: "primitive-ungrounded" });
+    }
+    if (isVar(variable)) {
+      bound.add(variable);
+    }
+    collectBodyEdges(nextBody, headPredicate, bound, edges);
+    return;
+  }
+  if (isPrimitiveFormula(body) && hasUnboundVariable(body, bound)) {
+    edges.push({ from: headPredicate, to: headPredicate, kind: "primitive-ungrounded" });
+  }
+}
+function collectAggregateEdges(aggregate, headPredicate, bound, edges) {
+  for (const arg of aggregate.args.slice(1)) {
+    collectBodyEdgesWithKind(arg, headPredicate, bound, edges, "aggregate");
+  }
+}
+function collectBodyEdgesWithKind(body, headPredicate, bound, edges, kind) {
+  if (isAtomLike(body)) {
+    edges.push({ from: headPredicate, to: body.predicate, kind });
+    bindVariables(body, bound);
+    return;
+  }
+  if (isNegativeLiteral(body)) {
+    edges.push({ from: headPredicate, to: body.atom.predicate, kind });
+    bindVariables(body.atom, bound);
+    return;
+  }
+  if (isFormula(body)) {
+    for (const arg of body.args) {
+      collectBodyEdgesWithKind(arg, headPredicate, bound, edges, kind);
+    }
+  }
+}
+
+// src/solver/query-validation/constructive-recursion.ts
+function assertConstructiveRecursion(context) {
+  const edges = context.rules.flatMap(ruleEdges);
+  const reachable = reachablePredicates(context.atom.predicate, edges);
+  const components = stronglyConnectedComponents(reachable, edges);
+  const needsCandidateEnumeration = variablesIn(context.atom).length > 0;
+  for (const component of components) {
+    const internalEdges = edges.filter(
+      (edge) => component.has(edge.from) && component.has(edge.to)
+    );
+    const recursive = component.size > 1 || internalEdges.some((edge) => edge.from === edge.to);
+    if (!recursive) {
+      continue;
+    }
+    if (internalEdges.some((edge) => edge.kind !== "positive")) {
+      throw new UnconstructiveRecursionProgrammerError();
+    }
+    const hasGroundEvidence = context.literals.some(
+      (literal) => component.has(literal.atom.predicate) && isGroundAtom(literal.atom)
+    );
+    if (needsCandidateEnumeration && !hasGroundEvidence && !hasNonRecursiveBaseRule(component, context.rules)) {
+      throw new UnconstructiveRecursionProgrammerError();
+    }
+  }
+}
+function hasNonRecursiveBaseRule(component, rules) {
+  return rules.some(
+    (rule) => component.has(rule.head.atom.predicate) && !bodyReferencesPredicates(rule.body, component)
+  );
+}
+function stronglyConnectedComponents(predicates, edges) {
+  const components = [];
+  const remaining = new Set(predicates);
+  for (const predicate of predicates) {
+    if (!remaining.has(predicate)) {
+      continue;
+    }
+    const forward = reachablePredicates(predicate, edges);
+    const backward = reachablePredicates(predicate, reverseEdges(edges));
+    const component = /* @__PURE__ */ new Set();
+    for (const candidate of predicates) {
+      if (forward.has(candidate) && backward.has(candidate)) {
+        component.add(candidate);
+        remaining.delete(candidate);
+      }
+    }
+    components.push(component);
+  }
+  return components;
+}
+function reverseEdges(edges) {
+  return edges.map((edge) => ({ ...edge, from: edge.to, to: edge.from }));
+}
+function bodyReferencesPredicates(body, predicates) {
+  if (isAtomLike(body)) {
+    return predicates.has(body.predicate);
+  }
+  if (isNegativeLiteral(body)) {
+    return predicates.has(body.atom.predicate);
+  }
+  if (isFormula(body)) {
+    return body.args.some((arg) => bodyReferencesPredicates(arg, predicates));
+  }
+  return false;
+}
+
+// src/solver/query-validation/constructive-variable-use.ts
+function assertConstructiveVariableUse(context) {
+  const edges = context.rules.flatMap(ruleEdges);
+  const reachable = reachablePredicates(context.atom.predicate, edges);
+  for (const rule of context.rules) {
+    if (!reachable.has(rule.head.atom.predicate)) {
+      continue;
+    }
+    assertSafeBody(rule.body, new Set(variablesIn(rule.head.atom)));
+  }
+}
+function assertSafeBody(body, bound) {
+  if (isAtomLike(body)) {
+    bindVariables(body, bound);
+    return bound;
+  }
+  if (isNegativeLiteral(body)) {
+    assertVariablesBound(variablesIn(body.atom), bound);
+    return bound;
+  }
+  if (isFormula(body, "and")) {
+    let nextBound = bound;
+    for (const arg of body.args) {
+      nextBound = assertSafeBody(arg, nextBound);
+    }
+    return nextBound;
+  }
+  if (isFormula(body, "or")) {
+    return bindingsAvailableAfterOr(body.args, bound);
+  }
+  if (isFormula(body, "exists")) {
+    const nextBody = body.args.at(-1);
+    if (nextBody !== void 0) {
+      assertSafeBody(nextBody, new Set(bound));
+    }
+    return bound;
+  }
+  if (isFormula(body, "letIn")) {
+    const [variable, value, nextBody] = body.args;
+    if (isAggregateFormula(value)) {
+      assertSafeAggregate(value, bound);
+    } else {
+      assertVariablesBound(variablesIn(value), bound);
+    }
+    if (isVar(variable)) {
+      bound.add(variable);
+    }
+    return assertSafeBody(nextBody, bound);
+  }
+  if (isPrimitiveFormula(body)) {
+    assertVariablesBound(variablesIn(body), bound);
+  }
+  return bound;
+}
+function assertSafeAggregate(aggregate, bound) {
+  const [value, whereBody, options] = aggregate.args;
+  const rowBindings = assertSafeBody(whereBody, new Set(bound));
+  if (aggregate.kind === "sum") {
+    assertVariablesBound(variablesIn(value), rowBindings);
+  }
+  if (isCompleteWhenOption(options)) {
+    assertSafeBody(options.completeWhen, new Set(bound));
+  }
+}
+function bindingsAvailableAfterOr(args, bound) {
+  const branchBindings = args.map((arg) => assertSafeBody(arg, new Set(bound)));
+  const next = new Set(bound);
+  for (const candidate of uniqueVariables(branchBindings.flatMap((branch) => [...branch]))) {
+    if (branchBindings.length > 0 && branchBindings.every((branch) => branch.has(candidate))) {
+      next.add(candidate);
+    }
+  }
+  return next;
+}
+function assertVariablesBound(variables, bound) {
+  const unbound = uniqueVariables(variables).filter((variable) => !bound.has(variable));
+  if (unbound.length > 0) {
+    throw new UnsafeUnboundVariableProgrammerError(unbound);
+  }
+}
+
+// src/solver/query-validation/validate-query.ts
+var queryValidations = [
+  assertConstructiveVariableUse,
+  assertConstructiveRecursion
+];
+function validateQuery(literals, rules, atom) {
+  const context = { literals, rules, atom };
+  for (const validate of queryValidations) {
+    validate(context);
+  }
+}
+
+// src/solver/goal-value.ts
+var GOAL_VALUE_RANK = {
+  false: 0,
+  unknown: 1,
+  conflicted: 2,
+  true: 3
+};
+var GOAL_VALUES_BY_RANK = ["false", "unknown", "conflicted", "true"];
+function rankGoalValue(value) {
+  return GOAL_VALUE_RANK[value];
+}
+function minGoalValue(...values) {
+  if (values.length === 0) {
+    return "true";
+  }
+  let rank = 3;
+  for (const value of values) {
+    rank = Math.min(rank, rankGoalValue(value));
+  }
+  return goalValueByRank(rank);
+}
+function maxGoalValue(...values) {
+  if (values.length === 0) {
+    return "false";
+  }
+  let rank = 0;
+  for (const value of values) {
+    rank = Math.max(rank, rankGoalValue(value));
+  }
+  return goalValueByRank(rank);
+}
+function negateGoalValue(value) {
+  switch (value) {
+    case "true":
+      return "false";
+    case "false":
+      return "true";
+    case "unknown":
+      return "unknown";
+    case "conflicted":
+      return "conflicted";
+    default:
+      throw new AssertionError("Unhandled goal value");
+  }
+}
+function negateAsFailureGoalValue(value) {
+  switch (value) {
+    case "true":
+      return "false";
+    case "false":
+      return "true";
+    case "unknown":
+      return "true";
+    case "conflicted":
+      return "conflicted";
+    default:
+      throw new AssertionError("Unhandled goal value");
+  }
+}
+function goalValueByRank(rank) {
+  const value = GOAL_VALUES_BY_RANK[rank];
+  if (value === void 0) {
+    throw new Error(`Invalid goal value rank: ${rank}`);
+  }
+  return value;
+}
+
+// src/solver/matching.ts
+function matchRuleForAtom(rule, atom) {
+  if (rule.head.atom.predicate !== atom.predicate) {
+    return void 0;
+  }
+  assertRuleMatchesAtom(rule, atom);
+  const bindings = matchPattern(rule.head.atom, atom);
+  if (bindings === void 0) {
+    return void 0;
+  }
+  return { rule, bindings };
+}
+function assertRuleMatchesAtom(rule, atom) {
+  assert(
+    rule.head.atom.predicate === atom.predicate,
+    "Rule head predicate does not match queried atom"
+  );
+}
+function matchPattern(pattern, atom) {
+  if (pattern.predicate !== atom.predicate) {
+    return void 0;
+  }
+  const bindings = /* @__PURE__ */ new Map();
+  for (const [name, patternValue] of Object.entries(pattern.fields)) {
+    const atomValue = atom.fields[name];
+    if (isVar(patternValue)) {
+      const boundValue = bindings.get(patternValue);
+      if (bindings.has(patternValue) && !fieldEquals(boundValue, atomValue)) {
+        return void 0;
+      }
+      bindings.set(patternValue, atomValue);
+      continue;
+    }
+    if (!fieldEquals(patternValue, atomValue)) {
+      return void 0;
+    }
+  }
+  return bindings;
+}
+function groundAtom(atom, bindings) {
+  const fields = {};
+  for (const [name, value] of Object.entries(atom.fields)) {
+    if (isVar(value)) {
+      assert(bindings.has(value), `No binding for variable ${value.name}`);
+      fields[name] = bindings.get(value);
+      continue;
+    }
+    fields[name] = value;
+  }
+  const grounded = { predicate: atom.predicate, fields };
+  assert(isAtomForPredicate(grounded, atom.predicate), "Grounded atom must retain its schema");
+  assertGroundAtom(grounded);
+  return grounded;
+}
+
+// src/solver/candidate-search.ts
+var CandidateSearch = class {
+  groups = /* @__PURE__ */ new Map();
+  tables = /* @__PURE__ */ new Map();
+  constructor(rules) {
+    const edges = rules.flatMap(ruleEdges);
+    for (const rule of rules) {
+      const predicate = rule.head.atom.predicate;
+      if (this.groups.has(predicate)) {
+        continue;
+      }
+      const group = { tables: /* @__PURE__ */ new Set(), evaluating: false, changed: false };
+      for (const dependency of reachablePredicates(predicate, edges)) {
+        if (reachablePredicates(dependency, edges).has(predicate)) {
+          this.groups.set(dependency, group);
+        }
+      }
+    }
+  }
+  candidates(atom, seeds, derive) {
+    let tables = this.tables.get(atom.predicate);
+    if (tables === void 0) {
+      tables = /* @__PURE__ */ new Map();
+      this.tables.set(atom.predicate, tables);
+    }
+    const key = patternKey(atom);
+    const existing = tables.get(key);
+    if (existing !== void 0) {
+      return [...existing.atoms.values()];
+    }
+    let group = this.groups.get(atom.predicate);
+    if (group === void 0) {
+      group = { tables: /* @__PURE__ */ new Set(), evaluating: false, changed: false };
+      this.groups.set(atom.predicate, group);
+    }
+    const table = {
+      atoms: new Map(seeds.map((seed) => [patternKey(seed), seed])),
+      derive
+    };
+    tables.set(key, table);
+    group.tables.add(table);
+    group.changed = true;
+    if (!group.evaluating) {
+      group.evaluating = true;
+      try {
+        do {
+          group.changed = false;
+          for (const member of [...group.tables]) {
+            group.changed = expandTable(member) || group.changed;
+          }
+        } while (group.changed);
+      } finally {
+        group.evaluating = false;
+      }
+    }
+    return [...table.atoms.values()];
+  }
+  sameComponent(left, right) {
+    return left === right || this.groups.has(left) && this.groups.get(left) === this.groups.get(right);
+  }
+  get isEvaluating() {
+    return [...this.groups.values()].some((group) => group.evaluating);
+  }
+};
+function expandTable(table) {
+  let changed = false;
+  for (const candidate of table.derive()) {
+    const key = patternKey(candidate);
+    if (!table.atoms.has(key)) {
+      table.atoms.set(key, candidate);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function patternKey(atom) {
+  const variables = /* @__PURE__ */ new Map();
+  return JSON.stringify(
+    atom.predicate.paramNames.map((name) => {
+      const value = atom.fields[name];
+      if (!isVar(value)) {
+        return ["value", fieldIdentityToken(value)];
+      }
+      let index = variables.get(value);
+      if (index === void 0) {
+        index = variables.size;
+        variables.set(value, index);
+      }
+      return ["variable", index];
+    })
+  );
+}
+
+// src/solver/solve-all.ts
+var UNBOUND = /* @__PURE__ */ Symbol("factbag.unbound");
+function solveQueryAll(literals, rules, atom) {
+  validateQuery(literals, rules, atom);
+  const result = solveQueryAllInternal(literals, rules, atom, /* @__PURE__ */ new Set(), {
+    candidates: new CandidateSearch(rules),
+    judgments: /* @__PURE__ */ new Map()
+  });
+  const stack = [result];
+  const visited = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const value = stack.pop();
+    assert(value !== UNBOUND, "Public query result must not contain UNBOUND");
+    if (typeof value === "object" && value !== null) {
+      if (visited.has(value)) {
+        continue;
+      }
+      visited.add(value);
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        stack.push(item);
+      }
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
+      for (const item of Object.values(value)) {
+        stack.push(item);
+      }
+    }
+  }
+  return result;
+}
+function solveQueryAllInternal(literals, rules, atom, active, search) {
+  if (isGroundAtom(atom)) {
+    const result = solveGroundAtom(literals, rules, atom, active, search);
+    assert(atomEquals(result.goal.atom, atom), "Ground query result must match queried atom");
+    return [result];
+  }
+  return candidateGroundAtoms(literals, rules, atom, active, search).map(
+    (candidate) => solveGroundAtom(literals, rules, candidate, active, search)
+  );
+}
+function solveGroundAtom(literals, rules, atom, active, search) {
+  if (search.candidates.isEvaluating) {
+    return evaluateGroundAtom(literals, rules, atom, active, search);
+  }
+  let judgments = search.judgments.get(atom.predicate);
+  if (judgments === void 0) {
+    judgments = /* @__PURE__ */ new Map();
+    search.judgments.set(atom.predicate, judgments);
+  }
+  const key = JSON.stringify([groundAtomKey(atom), [...active].sort()]);
+  const cached = judgments.get(key);
+  if (cached !== void 0 && judgmentMatchesAtom(cached, atom)) {
+    return cached;
+  }
+  const result = evaluateGroundAtom(literals, rules, atom, active, search);
+  judgments.set(key, result);
+  return result;
+}
+function judgmentMatchesAtom(judgment, atom) {
+  return atomEquals(judgment.goal.atom, atom);
+}
+function evaluateGroundAtom(literals, rules, atom, active, search) {
+  const goal = { kind: "atom", atom };
+  const bindings = [];
+  const atomKey = groundAtomKey(atom);
+  const positiveLiterals = matchingLiterals(literals, atom, "+");
+  const negativeLiterals = matchingLiterals(literals, atom, "-");
+  const values = [];
+  const positive = [];
+  const negative = [];
+  const inconclusive = [];
+  if (positiveLiterals.length > 0 && negativeLiterals.length > 0) {
+    values.push("conflicted");
+  } else if (positiveLiterals.length > 0) {
+    values.push("true");
+  } else if (negativeLiterals.length > 0) {
+    values.push("false");
+  }
+  if (!active.has(atomKey)) {
+    const nextActive = new Set(active);
+    nextActive.add(atomKey);
+    for (const rule of rules) {
+      const match = matchRuleForAtom(rule, atom);
+      if (match === void 0) {
+        continue;
+      }
+      const bodyResult = evaluateRuleBody(
+        literals,
+        rules,
+        match.rule.body,
+        match.bindings,
+        nextActive,
+        search
+      );
+      const body = bodyResult.judgment;
+      const contribution = ruleContribution(match.rule.kind, body.value);
+      const support = {
+        source: "rule",
+        rule: match.rule,
+        body
+      };
+      if (contribution === "unknown") {
+        inconclusive.push(support);
+        continue;
+      }
+      values.push(contribution);
+      if (contribution === "true" || contribution === "conflicted") {
+        positive.push(support);
+      }
+      if (contribution === "false" || contribution === "conflicted") {
+        negative.push(support);
+      }
+    }
+  }
+  if (values.length === 0) {
+    if (inconclusive.length > 0) {
+      return { value: "unknown", goal, bindings, inconclusive };
+    }
+    if (atom.predicate.world === "closed") {
+      assert(positiveLiterals.length === 0, "Closed-world absence requires no positive evidence");
+      assert(negativeLiterals.length === 0, "Closed-world absence requires no negative evidence");
+      assert(positive.length === 0, "Closed-world absence requires no positive rules");
+      assert(negative.length === 0, "Closed-world absence requires no negative rules");
+      assert(inconclusive.length === 0, "Closed-world absence requires no inconclusive rules");
+      return {
+        value: "false",
+        goal,
+        bindings,
+        negative: [{ source: "closed-world-absence" }]
+      };
+    }
+    return { value: "unknown", goal, bindings };
+  }
+  const hasEvidenceRuleConflict = positiveLiterals.length > 0 && negative.length > 0 || negativeLiterals.length > 0 && positive.length > 0;
+  const value = hasEvidenceRuleConflict ? "conflicted" : maxGoalValue(...values);
+  switch (value) {
+    case "conflicted":
+      return {
+        value,
+        goal,
+        bindings,
+        positive: [
+          ...positiveLiterals.length > 0 ? [{ source: "evidence", literals: positiveLiterals }] : [],
+          ...positive
+        ],
+        negative: [
+          ...negativeLiterals.length > 0 ? [{ source: "evidence", literals: negativeLiterals }] : [],
+          ...negative
+        ]
+      };
+    case "true":
+      return {
+        value,
+        goal,
+        bindings,
+        positive: [
+          ...positiveLiterals.length > 0 ? [{ source: "evidence", literals: positiveLiterals }] : [],
+          ...positive
+        ]
+      };
+    case "false":
+      return {
+        value,
+        goal,
+        bindings,
+        negative: [
+          ...negativeLiterals.length > 0 ? [{ source: "evidence", literals: negativeLiterals }] : [],
+          ...negative
+        ]
+      };
+    case "unknown":
+      return { value, goal, bindings };
+    default:
+      return assertNever(value, "Unhandled ground atom goal value");
+  }
+}
+function evaluateRuleBody(literals, rules, body, bindings, active, search) {
+  const context = {
+    nextTemp: 0,
+    search
+  };
+  const results = evaluateRuleBodyMany(literals, rules, body, bindings, active, context);
+  assert(results.length > 0, "Rule body evaluation produced no results");
+  const result = bestResult(results);
+  assert(result !== void 0, "Rule body evaluation produced no best result");
+  return result;
+}
+function assertNever(value, message) {
+  throw new AssertionError(`${message}: ${String(value)}`);
+}
+function evaluateRuleBodyMany(literals, rules, body, bindings, active, context, pathCanHaveUnavailableBindings = false) {
+  if (isAtomLike(body)) {
+    return evaluateAtomBody(literals, rules, erasedAtom(body), bindings, active, context);
+  }
+  if (isLiteralLike(body) && body.sign === "-") {
+    const bodyAtom = erasedAtom(body.atom);
+    if (!canGroundAtom(bodyAtom, bindings)) {
+      return [
+        {
+          judgment: {
+            value: "unknown",
+            goal: { kind: "not", goal: { kind: "atom", atom: body.atom } },
+            bindings: bindingsArray(bindings)
+          },
+          bindings
+        }
+      ];
+    }
+    const atom = groundAtom(bodyAtom, bindings);
+    assert(!active.has(groundAtomKey(atom)), "Validated query must not recurse through negation");
+    const child = solveGroundAtom(literals, rules, atom, active, context.search);
+    const goal = { kind: "not", goal: { kind: "atom", atom } };
+    const value = atom.predicate.world === "closed" ? negateAsFailureGoalValue(child.value) : negateGoalValue(child.value);
+    const judgmentBindings = bindingsArray(bindings);
+    switch (value) {
+      case "true":
+        return [
+          {
+            judgment: {
+              value,
+              goal,
+              bindings: judgmentBindings,
+              positive: [
+                { source: "subgoals", judgments: [withBindings(child, judgmentBindings)] }
+              ]
+            },
+            bindings
+          }
+        ];
+      case "false":
+        return [
+          {
+            judgment: {
+              value,
+              goal,
+              bindings: judgmentBindings,
+              negative: [
+                { source: "subgoals", judgments: [withBindings(child, judgmentBindings)] }
+              ]
+            },
+            bindings
+          }
+        ];
+      case "conflicted":
+        return [
+          {
+            judgment: {
+              value,
+              goal,
+              bindings: judgmentBindings,
+              positive: [
+                { source: "subgoals", judgments: [withBindings(child, judgmentBindings)] }
+              ],
+              negative: [
+                { source: "subgoals", judgments: [withBindings(child, judgmentBindings)] }
+              ]
+            },
+            bindings
+          }
+        ];
+      case "unknown":
+        return [
+          {
+            judgment: {
+              value,
+              goal,
+              bindings: judgmentBindings,
+              inconclusive: [
+                { source: "subgoals", judgments: [withBindings(child, judgmentBindings)] }
+              ]
+            },
+            bindings
+          }
+        ];
+      default:
+        return assertNever(value, "Unhandled negated goal value");
+    }
+  }
+  if (isFormula(body, "and")) {
+    return evaluateAndBody(
+      literals,
+      rules,
+      body.args,
+      bindings,
+      active,
+      context,
+      pathCanHaveUnavailableBindings
+    );
+  }
+  if (isFormula(body, "or")) {
+    return evaluateOrBody(
+      literals,
+      rules,
+      body.args,
+      bindings,
+      active,
+      context,
+      pathCanHaveUnavailableBindings
+    );
+  }
+  if (isFormula(body, "exists")) {
+    return evaluateExistsBody(
+      literals,
+      rules,
+      body.args,
+      bindings,
+      active,
+      context,
+      pathCanHaveUnavailableBindings
+    );
+  }
+  if (isLetInFormula(body)) {
+    return evaluateLetInBody(
+      literals,
+      rules,
+      body.args,
+      bindings,
+      active,
+      context,
+      pathCanHaveUnavailableBindings
+    );
+  }
+  if (isComparisonFormula(body)) {
+    return evaluateComparisonBody(
+      body.kind,
+      body.args,
+      bindings,
+      context,
+      pathCanHaveUnavailableBindings
+    );
+  }
+  assert(!isFormula(body), "Unsupported rule body formula");
+  throw new AssertionError("Unsupported rule body shape");
+}
+function evaluateExistsBody(literals, rules, args, bindings, active, context, pathCanHaveUnavailableBindings) {
+  const body = args.at(-1);
+  const variables = args.slice(0, -1);
+  assert(body !== void 0, "exists formula must include a body");
+  assert(variables.every(isVar), "exists formula quantifiers must be variables");
+  return evaluateRuleBodyMany(
+    literals,
+    rules,
+    body,
+    bindings,
+    active,
+    context,
+    pathCanHaveUnavailableBindings
+  ).map((result) => {
+    const judgmentBindings = bindingsArray(result.bindings);
+    const child = withBindings(result.judgment, judgmentBindings);
+    const goal = { kind: "exists", variables, goal: child.goal };
+    return {
+      judgment: compoundExistsJudgment(goal, child.value, judgmentBindings, [child]),
+      bindings: result.bindings
+    };
+  });
+}
+function evaluateOrBody(literals, rules, args, bindings, active, context, pathCanHaveUnavailableBindings) {
+  const candidateBindings = uniqueBindings(
+    args.flatMap(
+      (arg) => evaluateRuleBodyMany(
+        literals,
+        rules,
+        arg,
+        bindings,
+        active,
+        context,
+        pathCanHaveUnavailableBindings
+      ).map((result) => result.bindings)
+    )
+  );
+  const environments = candidateBindings.length === 0 ? [bindings] : candidateBindings;
+  return environments.map((environment) => {
+    const judgments = args.map((arg) => {
+      const results = evaluateRuleBodyMany(
+        literals,
+        rules,
+        arg,
+        environment,
+        active,
+        context,
+        pathCanHaveUnavailableBindings
+      );
+      assert(results.length > 0, "Or branch evaluation produced no results");
+      const result = bestResult(results);
+      assert(result !== void 0, "Or branch evaluation produced no best result");
+      return result.judgment;
+    });
+    const judgmentBindings = bindingsArray(environment);
+    const reboundJudgments = judgments.map((judgment) => withBindings(judgment, judgmentBindings));
+    const goal = { kind: "or", goals: reboundJudgments.map((judgment) => judgment.goal) };
+    return {
+      judgment: compoundJudgment(
+        goal,
+        maxGoalValue(...reboundJudgments.map((judgment) => judgment.value)),
+        judgmentBindings,
+        reboundJudgments
+      ),
+      bindings: environment
+    };
+  });
+}
+function evaluateAndBody(literals, rules, args, bindings, active, context, pathCanHaveUnavailableBindings) {
+  let partials = [{ bindings, judgments: [] }];
+  for (const arg of args) {
+    const next = [];
+    for (const partial of partials) {
+      const partialPathCanHaveUnavailableBindings = pathCanHaveUnavailableBindings || partial.judgments.some((judgment) => judgment.value !== "true");
+      const results = evaluateRuleBodyMany(
+        literals,
+        rules,
+        arg,
+        partial.bindings,
+        active,
+        context,
+        partialPathCanHaveUnavailableBindings
+      );
+      for (const result of results) {
+        next.push({
+          bindings: result.bindings,
+          judgments: [...partial.judgments, result.judgment]
+        });
+      }
+    }
+    partials = next;
+  }
+  return partials.map((partial) => {
+    const judgmentBindings = bindingsArray(partial.bindings);
+    const judgments = partial.judgments.map((judgment) => withBindings(judgment, judgmentBindings));
+    const goal = { kind: "and", goals: judgments.map((judgment) => judgment.goal) };
+    return {
+      judgment: compoundJudgment(
+        goal,
+        minGoalValue(...judgments.map((judgment) => judgment.value)),
+        judgmentBindings,
+        judgments
+      ),
+      bindings: partial.bindings
+    };
+  });
+}
+function evaluateAtomBody(literals, rules, atom, bindings, active, context) {
+  const evaluateGrounded = (environment) => {
+    const grounded = groundAtom(atom, environment);
+    const judgmentBindings = bindingsArray(environment);
+    const judgment = context.candidatePredicate !== void 0 && context.search.candidates.sameComponent(context.candidatePredicate, grounded.predicate) ? { value: "unknown", goal: { kind: "atom", atom: grounded }, bindings: judgmentBindings } : withBindings(
+      solveGroundAtom(literals, rules, grounded, active, context.search),
+      judgmentBindings
+    );
+    return { judgment, bindings: environment };
+  };
+  if (canGroundAtom(atom, bindings)) {
+    return [evaluateGrounded(bindings)];
+  }
+  const pattern = {
+    predicate: atom.predicate,
+    fields: Object.fromEntries(
+      Object.entries(atom.fields).map(([name, value]) => [
+        name,
+        isVar(value) && bindings.has(value) ? bindings.get(value) : value
+      ])
+    )
+  };
+  const candidateBindings = candidateGroundAtoms(literals, rules, pattern, active, context.search).map((candidate) => extendBindings(atom, candidate, bindings)).filter((candidate) => candidate !== void 0);
+  if (candidateBindings.length === 0) {
+    if (atom.predicate.world === "closed") {
+      assert(!canGroundAtom(atom, bindings), "Ground closed-world absence must use ground solving");
+      return [
+        {
+          judgment: {
+            value: "false",
+            goal: { kind: "atom", atom },
+            bindings: bindingsArray(bindings),
+            negative: [{ source: "closed-world-absence" }]
+          },
+          bindings
+        }
+      ];
+    }
+    return [
+      {
+        judgment: {
+          value: "unknown",
+          goal: { kind: "atom", atom },
+          bindings: bindingsArray(bindings)
+        },
+        bindings
+      }
+    ];
+  }
+  return candidateBindings.map(evaluateGrounded);
+}
+function evaluateComparisonBody(kind, args, bindings, context, pathCanHaveUnavailableBindings) {
+  const left = evaluateExpression(args[0], bindings, context);
+  const right = evaluateExpression(args[1], left.bindings, context);
+  assert(isScalarGoalExpression(left.expression), "Left comparison operand must be scalar");
+  assert(isScalarGoalExpression(right.expression), "Right comparison operand must be scalar");
+  const nextBindings = right.bindings;
+  const judgmentBindings = bindingsArray(nextBindings);
+  const goal = {
+    kind,
+    left: left.expression,
+    right: right.expression
+  };
+  const hasUnavailableOperand = left.value === UNBOUND || right.value === UNBOUND;
+  assert(
+    !hasUnavailableOperand || pathCanHaveUnavailableBindings,
+    "Primitive comparison operands must be bound"
+  );
+  const value = hasUnavailableOperand ? "unknown" : compareValues(kind, left.value, right.value);
+  const comparison = primitiveComparisonJudgment(
+    goal,
+    value,
+    judgmentBindings,
+    left.value,
+    left.expression,
+    right.value,
+    right.expression
+  );
+  const judgments = [...left.judgments, ...right.judgments, comparison];
+  if (judgments.length === 1) {
+    return [{ judgment: comparison, bindings: nextBindings }];
+  }
+  const andGoal = { kind: "and", goals: judgments.map((judgment) => judgment.goal) };
+  return [
+    {
+      judgment: compoundJudgment(
+        andGoal,
+        minGoalValue(...judgments.map((judgment) => judgment.value)),
+        judgmentBindings,
+        judgments
+      ),
+      bindings: nextBindings
+    }
+  ];
+}
+function evaluateLetInBody(literals, rules, args, bindings, active, context, pathCanHaveUnavailableBindings) {
+  const [variable, valueExpression, body] = args;
+  assert(isVar(variable), "letIn binder must be a variable");
+  if (isAggregateFormula2(valueExpression)) {
+    const aggregate = evaluateAggregateInto(
+      literals,
+      rules,
+      variable,
+      valueExpression,
+      bindings,
+      active,
+      context
+    );
+    switch (aggregate.kind) {
+      case "incomplete":
+        return [aggregate.result];
+      case "complete":
+        return evaluateLetBodyAfterValue(
+          literals,
+          rules,
+          body,
+          aggregate.expression,
+          active,
+          context,
+          pathCanHaveUnavailableBindings
+        );
+      default:
+        return assertNever(aggregate, "Unhandled aggregate evaluation kind");
+    }
+  }
+  if (isFormula(valueExpression) && !isArithmeticFormula(valueExpression)) {
+    assert(
+      isArithmeticFormula(valueExpression),
+      `Unsupported letIn value formula: ${valueExpression.kind}`
+    );
+  }
+  const value = evaluateExpressionInto(variable, valueExpression, bindings, context);
+  return evaluateLetBodyAfterValue(
+    literals,
+    rules,
+    body,
+    value,
+    active,
+    context,
+    pathCanHaveUnavailableBindings
+  );
+}
+function evaluateLetBodyAfterValue(literals, rules, body, value, active, context, pathCanHaveUnavailableBindings) {
+  const results = evaluateRuleBodyMany(
+    literals,
+    rules,
+    body,
+    value.bindings,
+    active,
+    context,
+    pathCanHaveUnavailableBindings || value.judgments.some((judgment) => judgment.value !== "true")
+  );
+  return results.map((result) => {
+    const judgmentBindings = bindingsArray(result.bindings);
+    const judgments = [...value.judgments, result.judgment].map(
+      (judgment) => withBindings(judgment, judgmentBindings)
+    );
+    const goal = { kind: "and", goals: judgments.map((judgment) => judgment.goal) };
+    return {
+      judgment: compoundJudgment(
+        goal,
+        minGoalValue(...judgments.map((judgment) => judgment.value)),
+        judgmentBindings,
+        judgments
+      ),
+      bindings: result.bindings
+    };
+  });
+}
+function valueForVariable(bindings, variable) {
+  if (!bindings.has(variable)) {
+    return UNBOUND;
+  }
+  return definedValue(bindings.get(variable), "Bound variable values must be defined");
+}
+function definedValue(value, message) {
+  assert(isDefinedValue(value), message);
+  return value;
+}
+function isDefinedValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || typeof value === "object" && value !== null;
+}
+function isGoalExpression(value) {
+  return isVar(value) || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || value instanceof Date || typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";
+}
+function isScalarGoalExpression(value) {
+  return isVar(value) || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || value instanceof Date;
+}
+function isNumericGoalExpression(value) {
+  return isVar(value) || typeof value === "number" || typeof value === "bigint";
+}
+function evaluateExpression(expression, bindings, context) {
+  if (isVar(expression)) {
+    return {
+      value: valueForVariable(bindings, expression),
+      expression,
+      bindings,
+      judgments: []
+    };
+  }
+  if (isArithmeticFormula(expression)) {
+    const left = evaluateExpression(expression.args[0], bindings, context);
+    const right = evaluateExpression(expression.args[1], left.bindings, context);
+    assert(isScalarGoalExpression(left.expression), "Left arithmetic operand must be scalar");
+    assert(isScalarGoalExpression(right.expression), "Right arithmetic operand must be scalar");
+    const variable = new Var(`$tmp${context.nextTemp++}`);
+    const goal = {
+      kind: expression.kind,
+      bind: variable,
+      left: left.expression,
+      right: right.expression
+    };
+    const value = calculateValue(expression.kind, left.value, right.value, goal);
+    const nextBindings = new Map(right.bindings);
+    if (value !== UNBOUND) {
+      nextBindings.set(variable, value);
+    }
+    const judgmentBindings = bindingsArray(nextBindings);
+    const judgment = primitiveArithmeticJudgment(
+      goal,
+      judgmentBindings,
+      left.value,
+      left.expression,
+      right.value,
+      right.expression,
+      variable,
+      value
+    );
+    return {
+      value,
+      expression: variable,
+      bindings: nextBindings,
+      judgments: [...left.judgments, ...right.judgments, judgment]
+    };
+  }
+  assert(isGoalExpression(expression), "Expression must be a scalar, entity, or variable");
+  return {
+    value: definedValue(expression, "Expression values must be defined"),
+    expression,
+    bindings,
+    judgments: []
+  };
+}
+function evaluateExpressionInto(variable, expression, bindings, context) {
+  if (isArithmeticFormula(expression)) {
+    const left = evaluateExpression(expression.args[0], bindings, context);
+    const right = evaluateExpression(expression.args[1], left.bindings, context);
+    assert(isScalarGoalExpression(left.expression), "Left arithmetic operand must be scalar");
+    assert(isScalarGoalExpression(right.expression), "Right arithmetic operand must be scalar");
+    const goal = {
+      kind: expression.kind,
+      bind: variable,
+      left: left.expression,
+      right: right.expression
+    };
+    const value2 = calculateValue(expression.kind, left.value, right.value, goal);
+    const nextBindings2 = new Map(right.bindings);
+    if (value2 !== UNBOUND) {
+      nextBindings2.set(variable, value2);
+    }
+    const judgmentBindings = bindingsArray(nextBindings2);
+    const judgment = primitiveArithmeticJudgment(
+      goal,
+      judgmentBindings,
+      left.value,
+      left.expression,
+      right.value,
+      right.expression,
+      variable,
+      value2
+    );
+    return {
+      value: value2,
+      expression: variable,
+      bindings: nextBindings2,
+      judgments: [...left.judgments, ...right.judgments, judgment]
+    };
+  }
+  const value = isVar(expression) ? valueForVariable(bindings, expression) : definedValue(expression, "Expression values must be defined");
+  const nextBindings = new Map(bindings);
+  nextBindings.set(variable, value);
+  return { value, expression: variable, bindings: nextBindings, judgments: [] };
+}
+function evaluateAggregateInto(literals, rules, variable, aggregate, bindings, active, context) {
+  const [valueExpression, whereBody, options] = aggregate.args;
+  const completeWhen = options?.completeWhen;
+  const rowResults = evaluateRuleBodyMany(literals, rules, whereBody, bindings, active, context);
+  const rows = rowResults.filter((result) => result.judgment.value === "true");
+  const possibleRows = rowResults.filter(
+    (result) => result.judgment.value !== "false" && (aggregate.kind !== "count" || aggregateValueIsAvailable(valueExpression, result.bindings))
+  );
+  const whereGoal = aggregateWhereGoal(possibleRows.map((row) => row.judgment));
+  if (completeWhen !== void 0) {
+    const completenessResults = evaluateRuleBodyMany(
+      literals,
+      rules,
+      completeWhen,
+      bindings,
+      active,
+      context
+    );
+    assert(completenessResults.length > 0, "Aggregate completeness evaluation produced no results");
+    const completeness = bestResult(completenessResults);
+    assert(completeness !== void 0, "Aggregate completeness evaluation produced no best result");
+    if (completeness.judgment.value !== "true") {
+      const judgmentBindings = bindingsArray(bindings);
+      let goal;
+      switch (aggregate.kind) {
+        case "sum":
+          assert(isNumericGoalExpression(valueExpression), "Sum value must be numeric");
+          goal = {
+            kind: "sum",
+            bind: variable,
+            value: valueExpression,
+            where: whereGoal,
+            completeWhen: completeness.judgment.goal
+          };
+          break;
+        case "count":
+          goal = {
+            kind: "count",
+            bind: variable,
+            where: whereGoal,
+            completeWhen: completeness.judgment.goal
+          };
+          break;
+        default:
+          return assertNever(aggregate.kind, "Unhandled aggregate kind");
+      }
+      return {
+        kind: "incomplete",
+        result: {
+          judgment: { value: "unknown", goal, bindings: judgmentBindings },
+          bindings
+        }
+      };
+    }
+  }
+  const nextBindings = new Map(bindings);
+  const values = rows.map((row) => resolveAggregateValue(valueExpression, row.bindings));
+  let value;
+  let judgment;
+  switch (aggregate.kind) {
+    case "sum":
+      assert(isNumericGoalExpression(valueExpression), "Sum value must be numeric");
+      value = sumValues(values);
+      nextBindings.set(variable, value);
+      judgment = primitiveSumJudgment(
+        {
+          kind: "sum",
+          bind: variable,
+          value: valueExpression,
+          where: whereGoal
+        },
+        bindingsArray(nextBindings),
+        values,
+        variable,
+        value
+      );
+      break;
+    case "count": {
+      const range = countRange(possibleRows, isOpenAggregate(whereBody));
+      value = exactCountValue(range);
+      nextBindings.set(variable, value);
+      judgment = primitiveCountJudgment(
+        { kind: "count", bind: variable, where: whereGoal },
+        bindingsArray(nextBindings),
+        range,
+        variable,
+        value
+      );
+      break;
+    }
+    default:
+      return assertNever(aggregate.kind, "Unhandled aggregate kind");
+  }
+  return {
+    kind: "complete",
+    expression: { value, expression: variable, bindings: nextBindings, judgments: [judgment] }
+  };
+}
+function resolveAggregateValue(expression, bindings) {
+  const value = isVar(expression) ? valueForVariable(bindings, expression) : definedValue(expression, "Aggregate values must be defined");
+  assert(value !== UNBOUND, "Aggregate variables must be bound");
+  return value;
+}
+function aggregateValueIsAvailable(expression, bindings) {
+  if (!isVar(expression)) {
+    return expression !== void 0;
+  }
+  return valueForVariable(bindings, expression) !== UNBOUND;
+}
+function sumValues(values) {
+  if (values.every((value) => typeof value === "bigint")) {
+    return values.reduce((total, value) => total + value, 0n);
+  }
+  return values.reduce((total, value) => total + Number(value), 0);
+}
+function aggregateWhereGoal(judgments) {
+  if (judgments.length === 1) {
+    const judgment = judgments[0];
+    assert(judgment !== void 0, "Expected one aggregate row judgment");
+    return judgment.goal;
+  }
+  return { kind: "or", goals: judgments.map((judgment) => judgment.goal) };
+}
+function countRange(rows, open) {
+  const definite = rows.filter((row) => row.judgment.value === "true").length;
+  const conflicted = rows.filter((row) => row.judgment.value === "conflicted").length;
+  const unknown = rows.filter((row) => row.judgment.value === "unknown").length;
+  const uncertainty = [];
+  if (conflicted > 0) {
+    uncertainty.push({ kind: "conflict", count: conflicted });
+  }
+  if (unknown > 0) {
+    uncertainty.push({ kind: "unknown", count: unknown });
+  }
+  if (open) {
+    uncertainty.push({ kind: "open-world" });
+  }
+  return {
+    kind: "numeric-range",
+    lower: definite,
+    upper: open ? "infinity" : definite + conflicted + unknown,
+    uncertainty
+  };
+}
+function exactCountValue(range) {
+  return range.uncertainty.length === 0 && range.upper !== "infinity" && range.lower === range.upper ? range.lower : range;
+}
+function isOpenAggregate(whereBody) {
+  if (isAtomLike(whereBody)) {
+    return whereBody.predicate.world === "open";
+  }
+  if (isFormula(whereBody, "and") || isFormula(whereBody, "or")) {
+    return whereBody.args.some(isOpenAggregate);
+  }
+  if (isFormula(whereBody, "exists")) {
+    const body = whereBody.args.at(-1);
+    return body !== void 0 && isOpenAggregate(body);
+  }
+  return true;
+}
+function primitiveSumJudgment(goal, bindings, values, variable, value) {
+  return {
+    value: "true",
+    goal,
+    bindings,
+    positive: [
+      primitiveSupport({
+        operation: "sum",
+        operands: values,
+        value: "true",
+        result: value,
+        results: [[variable, value]],
+        ...primitiveRangeForExact(value)
+      })
+    ]
+  };
+}
+function primitiveCountJudgment(goal, bindings, range, variable, value) {
+  return {
+    value: "true",
+    goal,
+    bindings,
+    positive: [
+      primitiveSupport({
+        operation: "count",
+        operands: [],
+        value: "true",
+        result: value,
+        results: [[variable, value]],
+        range: { lower: range.lower, upper: range.upper },
+        ...range.uncertainty.length === 0 ? {} : { uncertainty: range.uncertainty }
+      })
+    ]
+  };
+}
+function primitiveArithmeticJudgment(goal, bindings, left, leftExpression, right, rightExpression, variable, value) {
+  if (value === UNBOUND) {
+    assert(
+      left === UNBOUND || right === UNBOUND,
+      "Unknown primitive arithmetic requires an unavailable operand"
+    );
+    const evaluation = {
+      operation: goal.kind,
+      operands: [publicOperand(left, leftExpression), publicOperand(right, rightExpression)],
+      value: "unknown",
+      uncertainty: missingBindingUncertainty(left, leftExpression, right, rightExpression)
+    };
+    return { value: "unknown", goal, bindings, inconclusive: [primitiveSupport(evaluation)] };
+  }
+  return {
+    value: "true",
+    goal,
+    bindings,
+    positive: [
+      primitiveSupport({
+        operation: goal.kind,
+        operands: [left, right],
+        value: "true",
+        result: value,
+        results: [[variable, value]],
+        ...primitiveRangeForExact(value)
+      })
+    ]
+  };
+}
+function primitiveComparisonJudgment(goal, value, bindings, left, leftExpression, right, rightExpression) {
+  const support = primitiveSupport({
+    operation: goal.kind,
+    operands: [publicOperand(left, leftExpression), publicOperand(right, rightExpression)],
+    value,
+    ...isNumericRangeValue(left) ? { range: { lower: left.lower, upper: left.upper } } : {},
+    ...isNumericRangeValue(right) ? { range: { lower: right.lower, upper: right.upper } } : {},
+    ...primitiveUncertaintyForComparison(value, left, leftExpression, right, rightExpression)
+  });
+  assert(
+    value === "unknown" || left !== UNBOUND && right !== UNBOUND,
+    "Resolved primitive comparison operands must be bound"
+  );
+  assert(
+    value !== "unknown" || left === UNBOUND || right === UNBOUND || isNumericRangeValue(left) || isNumericRangeValue(right),
+    "Unknown primitive comparison requires an unavailable operand"
+  );
+  switch (value) {
+    case "true":
+      return { value, goal, bindings, positive: [support] };
+    case "false":
+      return { value, goal, bindings, negative: [support] };
+    case "unknown":
+      return { value, goal, bindings, inconclusive: [support] };
+    case "conflicted":
+      return { value, goal, bindings, positive: [support], negative: [support] };
+    default:
+      return assertNever(value, "Unhandled primitive comparison value");
+  }
+}
+function primitiveSupport(evaluation) {
+  return { source: "primitive", evaluation };
+}
+function publicOperand(value, expression) {
+  return value === UNBOUND ? missingBinding(expression) : value;
+}
+function missingBinding(expression) {
+  assert(isVar(expression), "Only variables can have missing bindings");
+  return { kind: "missing-binding", variable: expression };
+}
+function missingBindingUncertainty(left, leftExpression, right, rightExpression) {
+  return [
+    ...left === UNBOUND ? [missingBinding(leftExpression)] : [],
+    ...right === UNBOUND ? [missingBinding(rightExpression)] : []
+  ];
+}
+function primitiveUncertaintyForComparison(value, left, leftExpression, right, rightExpression) {
+  if (left === UNBOUND || right === UNBOUND) {
+    return { uncertainty: missingBindingUncertainty(left, leftExpression, right, rightExpression) };
+  }
+  if (value === "true" || value === "false") {
+    return {};
+  }
+  if (isNumericRangeValue(left)) {
+    return { uncertainty: comparisonUncertainty(value, left) };
+  }
+  if (isNumericRangeValue(right)) {
+    return { uncertainty: comparisonUncertainty(value, right) };
+  }
+  return {};
+}
+function primitiveRangeForExact(value) {
+  if (typeof value !== "number" && typeof value !== "bigint") {
+    return {};
+  }
+  return { range: { lower: value, upper: value } };
+}
+function isArithmeticFormula(value) {
+  return isFormula(value) && ["add", "sub", "mul", "div"].includes(value.kind) && value.args.length === 2;
+}
+function isComparisonFormula(value) {
+  return isFormula(value) && ["eq", "neq", "lt", "lte", "gt", "gte"].includes(value.kind) && value.args.length === 2;
+}
+function isLetInFormula(value) {
+  return isFormula(value, "letIn") && value.args.length === 3;
+}
+function isAggregateFormula2(value) {
+  return isFormula(value) && (value.kind === "sum" || value.kind === "count") && (value.args.length === 2 || value.args.length === 3);
+}
+function isLiteralLike(value) {
+  return typeof value === "object" && value !== null && "sign" in value && (value.sign === "+" || value.sign === "-") && "atom" in value && isAtomLike(value.atom);
+}
+function calculateValue(kind, left, right, goal) {
+  if (left === UNBOUND || right === UNBOUND) {
+    return UNBOUND;
+  }
+  if (left instanceof Date && typeof right === "number") {
+    switch (kind) {
+      case "sub":
+        return new Date(left.getTime() - right);
+      case "add":
+      case "mul":
+      case "div":
+        break;
+      default:
+        return assertNever(kind, "Unhandled arithmetic kind");
+    }
+  }
+  if (typeof left === "number" && typeof right === "number") {
+    switch (kind) {
+      case "add":
+        return left + right;
+      case "sub":
+        return left - right;
+      case "mul":
+        return left * right;
+      case "div":
+        return left / right;
+      default:
+        return assertNever(kind, "Unhandled arithmetic kind");
+    }
+  }
+  if (typeof left === "bigint" && typeof right === "bigint") {
+    switch (kind) {
+      case "add":
+        return left + right;
+      case "sub":
+        return left - right;
+      case "mul":
+        return left * right;
+      case "div":
+        return left / right;
+      default:
+        return assertNever(kind, "Unhandled arithmetic kind");
+    }
+  }
+  throw new PrimitiveArithmeticProgrammerError(kind, [left, right], goal);
+}
+function compareValues(kind, left, right) {
+  assert(left !== UNBOUND && right !== UNBOUND, "Comparison operands must be bound");
+  if (isNumericRangeValue(left) && typeof right === "number") {
+    return compareRangeToNumber(kind, left, right);
+  }
+  if (typeof left === "number" && isNumericRangeValue(right)) {
+    return compareNumberToRange(kind, left, right);
+  }
+  const leftComparable = left instanceof Date ? left.getTime() : left;
+  const rightComparable = right instanceof Date ? right.getTime() : right;
+  switch (kind) {
+    case "eq":
+      return leftComparable === rightComparable ? "true" : "false";
+    case "neq":
+      return leftComparable === rightComparable ? "false" : "true";
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte":
+      return compareOrderedValues(kind, leftComparable, rightComparable);
+    default:
+      return assertNever(kind, "Unhandled comparison kind");
+  }
+}
+function compareOrderedValues(kind, left, right) {
+  assert(
+    (typeof left === "number" || typeof left === "bigint") && (typeof right === "number" || typeof right === "bigint"),
+    "Values must be comparable"
+  );
+  switch (kind) {
+    case "lt":
+      return left < right ? "true" : "false";
+    case "lte":
+      return left <= right ? "true" : "false";
+    case "gt":
+      return left > right ? "true" : "false";
+    case "gte":
+      return left >= right ? "true" : "false";
+    default:
+      return assertNever(kind, "Unhandled ordered comparison kind");
+  }
+}
+function compareRangeToNumber(kind, range, threshold) {
+  switch (kind) {
+    case "gte":
+      if (range.lower >= threshold) {
+        return "true";
+      }
+      if (range.upper !== "infinity" && range.upper < threshold) {
+        return "false";
+      }
+      return intervalUncertaintyValue(kind, range, threshold);
+    case "gt":
+      if (range.lower > threshold) {
+        return "true";
+      }
+      if (range.upper !== "infinity" && range.upper <= threshold) {
+        return "false";
+      }
+      return intervalUncertaintyValue(kind, range, threshold);
+    case "lte":
+      if (range.upper !== "infinity" && range.upper <= threshold) {
+        return "true";
+      }
+      if (range.lower > threshold) {
+        return "false";
+      }
+      return intervalUncertaintyValue(kind, range, threshold);
+    case "lt":
+      if (range.upper !== "infinity" && range.upper < threshold) {
+        return "true";
+      }
+      if (range.lower >= threshold) {
+        return "false";
+      }
+      return intervalUncertaintyValue(kind, range, threshold);
+    case "eq":
+    case "neq":
+      return range.upper !== "infinity" && range.lower === range.upper ? compareValues(kind, range.lower, threshold) : intervalUncertaintyValue(kind, range, threshold);
+    default:
+      return assertNever(kind, "Unhandled range comparison kind");
+  }
+}
+function compareNumberToRange(kind, value, range) {
+  switch (kind) {
+    case "gte":
+      return compareRangeToNumber("lte", range, value);
+    case "gt":
+      return compareRangeToNumber("lt", range, value);
+    case "lte":
+      return compareRangeToNumber("gte", range, value);
+    case "lt":
+      return compareRangeToNumber("gt", range, value);
+    case "eq":
+    case "neq":
+      return compareRangeToNumber(kind, range, value);
+    default:
+      return assertNever(kind, "Unhandled number-to-range comparison kind");
+  }
+}
+function intervalUncertaintyValue(kind, range, threshold) {
+  return conflictCanDecide(kind, range, threshold) ? "conflicted" : "unknown";
+}
+function conflictCanDecide(kind, range, threshold) {
+  const conflicted = range.uncertainty.find((item) => item.kind === "conflict")?.count ?? 0;
+  if (conflicted === 0) {
+    return false;
+  }
+  const conflictUpper = range.lower + conflicted;
+  switch (kind) {
+    case "gte":
+      return range.lower < threshold && threshold <= conflictUpper;
+    case "gt":
+      return range.lower <= threshold && threshold < conflictUpper;
+    case "lte":
+      return range.lower <= threshold && threshold < conflictUpper;
+    case "lt":
+      return range.lower < threshold && threshold <= conflictUpper;
+    case "eq":
+    case "neq":
+      return range.lower <= threshold && threshold <= conflictUpper;
+    default:
+      return assertNever(kind, "Unhandled conflict range comparison kind");
+  }
+}
+function comparisonUncertainty(value, range) {
+  if (value === "conflicted") {
+    return range.uncertainty.filter((item) => item.kind === "conflict");
+  }
+  if (value === "unknown") {
+    return range.uncertainty.filter((item) => item.kind !== "conflict");
+  }
+  return [];
+}
+function isNumericRangeValue(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "numeric-range";
+}
+function bestResult(results) {
+  return results.reduce((best, result) => {
+    if (best === void 0) {
+      return result;
+    }
+    return maxGoalValue(best.judgment.value, result.judgment.value) === result.judgment.value ? result : best;
+  }, void 0);
+}
+function extendBindings(pattern, atom, bindings) {
+  const matched = matchPattern(pattern, atom);
+  if (matched === void 0) {
+    return void 0;
+  }
+  const next = new Map(bindings);
+  for (const [variable, value] of matched) {
+    if (next.has(variable) && !fieldEquals(next.get(variable), value)) {
+      return void 0;
+    }
+    next.set(variable, value);
+  }
+  return next;
+}
+function compoundJudgment(goal, value, bindings, judgments) {
+  const support = { source: "subgoals", judgments };
+  switch (value) {
+    case "true":
+      return { value, goal, bindings, positive: [support] };
+    case "false":
+      return { value, goal, bindings, negative: [support] };
+    case "conflicted":
+      return { value, goal, bindings, positive: [support], negative: [support] };
+    case "unknown":
+      return { value, goal, bindings, inconclusive: [support] };
+    default:
+      return assertNever(value, "Unhandled compound goal value");
+  }
+}
+function compoundExistsJudgment(goal, value, bindings, judgments) {
+  const support = { source: "subgoals", judgments };
+  switch (value) {
+    case "true":
+      return { value, goal, bindings, positive: [support] };
+    case "false":
+      return { value, goal, bindings, negative: [support] };
+    case "conflicted":
+      return { value, goal, bindings, positive: [support], negative: [support] };
+    case "unknown":
+      return { value, goal, bindings, inconclusive: [support] };
+    default:
+      return assertNever(value, "Unhandled exists goal value");
+  }
+}
+function withBindings(judgment, bindings) {
+  return { ...judgment, bindings };
+}
+function ruleContribution(kind, value) {
+  return kind === "if" && value === "false" ? "unknown" : value;
+}
+function bindingsArray(bindings) {
+  return [...bindings.entries()];
+}
+function uniqueBindings(bindings) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const binding of bindings) {
+    const key = JSON.stringify(
+      bindingsArray(binding).map(([variable, value]) => [variable.name, fieldIdentityToken(value)])
+    );
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(binding);
+    }
+  }
+  return unique;
+}
+function canGroundAtom(atom, bindings) {
+  return Object.values(atom.fields).every((value) => !isVar(value) || bindings.has(value));
+}
+function groundAtomKey(atom) {
+  const fields = atom.predicate.paramNames.map((name) => fieldIdentityToken(atom.fields[name]));
+  return `${atom.predicate.name}:${JSON.stringify(fields)}`;
+}
+function candidateGroundAtoms(literals, rules, atom, active, search) {
+  return search.candidates.candidates(
+    atom,
+    matchingGroundAtoms(literals, atom),
+    () => deriveCandidateAtoms(literals, rules, atom, active, search)
+  ).filter(
+    (candidate) => isAtomForPredicate(candidate, atom.predicate)
+  );
+}
+function deriveCandidateAtoms(literals, rules, atom, active, search) {
+  const atoms = [];
+  for (const rule of rules) {
+    const ruleHead = atomForPredicate(rule.head.atom, atom.predicate);
+    if (ruleHead === void 0) {
+      continue;
+    }
+    const bindings = matchRuleHeadToQuery(ruleHead, atom);
+    if (bindings === void 0) {
+      continue;
+    }
+    const context = { nextTemp: 0, search, candidatePredicate: atom.predicate };
+    const bodies = evaluateRuleBodyMany(literals, rules, rule.body, bindings, active, context);
+    for (const body of bodies) {
+      if (!canGroundAtom(ruleHead, body.bindings)) {
+        continue;
+      }
+      const candidate = groundAtom(ruleHead, body.bindings);
+      if (!matchesAtom(candidate, atom) || atoms.some((existing) => atomEquals(existing, candidate))) {
+        continue;
+      }
+      atoms.push(candidate);
+    }
+  }
+  return atoms;
+}
+function matchRuleHeadToQuery(ruleHead, query2) {
+  if (ruleHead.predicate !== query2.predicate) {
+    return void 0;
+  }
+  const bindings = /* @__PURE__ */ new Map();
+  for (const [name, ruleValue] of Object.entries(ruleHead.fields)) {
+    const queryValue = query2.fields[name];
+    if (isVar(queryValue)) {
+      continue;
+    }
+    if (isVar(ruleValue)) {
+      const boundValue = bindings.get(ruleValue);
+      if (bindings.has(ruleValue) && !fieldEquals(boundValue, queryValue)) {
+        return void 0;
+      }
+      bindings.set(ruleValue, queryValue);
+      continue;
+    }
+    if (!fieldEquals(ruleValue, queryValue)) {
+      return void 0;
+    }
+  }
+  return bindings;
+}
+function matchingGroundAtoms(literals, atom) {
+  const atoms = [];
+  for (const literal of literals) {
+    const literalAtom = atomForPredicate(literal.atom, atom.predicate);
+    if (literalAtom === void 0 || !isGroundAtom(literalAtom)) {
+      continue;
+    }
+    if (!matchesAtom(literalAtom, atom)) {
+      continue;
+    }
+    if (atoms.some((candidate) => atomEquals(candidate, literalAtom))) {
+      continue;
+    }
+    atoms.push(literalAtom);
+  }
+  return atoms;
+}
+function matchesAtom(candidate, atom) {
+  return matchPattern(atom, candidate) !== void 0;
+}
+function matchingLiterals(literals, atom, sign) {
+  return literals.filter((literal) => {
+    const literalAtom = atomForPredicate(literal.atom, atom.predicate);
+    return literal.sign === sign && literalAtom !== void 0 && atomEquals(literalAtom, atom);
+  });
+}
+function erasedAtom(atom) {
+  return atom;
+}
+function atomForPredicate(atom, predicate) {
+  if (!isAtomForPredicate(atom, predicate)) {
+    return void 0;
+  }
+  return atom;
+}
+
+// src/solver/solve.ts
+function solveQuery(literals, rules, atom) {
+  const results = solveQueryAll(literals, rules, atom);
+  const [result] = results;
+  assert(result !== void 0, "Ground query must produce one result");
+  return result;
+}
+
+// src/query/query.ts
+function query(kb, atom) {
+  return solveQuery(kb.literals(), kb.rules(), atom);
+}
+function queryAll(kb, pattern) {
+  return solveQueryAll(kb.literals(), kb.rules(), pattern);
+}
+export {
+  query,
+  queryAll
+};