factbag 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/core/query/index.js

@@ -1,11 +1,11 @@
 import {
   isFormula
-} from "../chunk-A6ZZJWIO.js";
+} from "../chunk-NDUIQAH4.js";
 import {
   PrimitiveArithmeticProgrammerError,
   UnconstructiveRecursionProgrammerError,
   UnsafeUnboundVariableProgrammerError
-} from "../chunk-X3LSDJL4.js";
+} from "../chunk-QOMFY3XB.js";
 import {
   assertGroundAtom,
   atomEquals,
@@ -13,8 +13,9 @@ import {
   fieldIdentityToken,
   isAtomForPredicate,
   isAtomLike,
+  isEntityValue,
   isGroundAtom
-} from "../chunk-5J3WGMN2.js";
+} from "../chunk-N2RRSOEN.js";
 import {
   AssertionError,
   Var,
@@ -22,6 +23,39 @@ import {
   isVar
 } from "../chunk-UVOCOH2I.js";
 
+// src/solver/calendar.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function utcDay(date) {
+  return Math.floor(date.getTime() / DAY_MS);
+}
+function daysBetween(later, earlier) {
+  return utcDay(later) - utcDay(earlier);
+}
+function yearsBetween(later, earlier) {
+  if (later.getTime() < earlier.getTime()) {
+    return -yearsBetween(earlier, later) || 0;
+  }
+  const years = later.getUTCFullYear() - earlier.getUTCFullYear();
+  const laterDay = later.getUTCMonth() * 100 + later.getUTCDate();
+  const earlierDay = earlier.getUTCMonth() * 100 + earlier.getUTCDate();
+  return laterDay < earlierDay ? years - 1 : years;
+}
+
+// src/types/goal.ts
+var ARITHMETIC_KINDS = [
+  "add",
+  "sub",
+  "mul",
+  "div",
+  "daysBetween",
+  "yearsBetween",
+  "min",
+  "max",
+  "roundTo",
+  "floorTo",
+  "ceilTo"
+];
+
 // src/solver/query-validation/utils.ts
 function ruleEdges(rule) {
   const headPredicate = rule.head.atom.predicate;
@@ -31,6 +65,7 @@ function ruleEdges(rule) {
   return edges;
 }
 function reachablePredicates(start, edges) {
+  const next = adjacency(edges);
   const reachable = /* @__PURE__ */ new Set([start]);
   const stack = [start];
   while (stack.length > 0) {
@@ -38,16 +73,71 @@ function reachablePredicates(start, edges) {
     if (current === void 0) {
       continue;
     }
-    for (const edge of edges) {
-      if (edge.from !== current || reachable.has(edge.to)) {
+    for (const target of next.get(current) ?? []) {
+      if (reachable.has(target)) {
         continue;
       }
-      reachable.add(edge.to);
-      stack.push(edge.to);
+      reachable.add(target);
+      stack.push(target);
     }
   }
   return reachable;
 }
+function adjacency(edges) {
+  const next = /* @__PURE__ */ new Map();
+  for (const { from, to } of edges) {
+    let targets = next.get(from);
+    if (targets === void 0) {
+      targets = /* @__PURE__ */ new Set();
+      next.set(from, targets);
+    }
+    targets.add(to);
+  }
+  return next;
+}
+function stronglyConnectedComponents(edges) {
+  const next = adjacency(edges);
+  const indices = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const components = /* @__PURE__ */ new Map();
+  function visit(predicate) {
+    const index = indices.size;
+    indices.set(predicate, index);
+    let lowLink = index;
+    stack.push(predicate);
+    onStack.add(predicate);
+    for (const target of next.get(predicate) ?? []) {
+      const targetIndex = indices.get(target);
+      if (targetIndex === void 0) {
+        const targetLowLink = visit(target);
+        lowLink = Math.min(lowLink, targetLowLink);
+      } else if (onStack.has(target)) {
+        lowLink = Math.min(lowLink, targetIndex);
+      }
+    }
+    if (lowLink === index) {
+      const component = /* @__PURE__ */ new Set();
+      for (let member = stack.pop(); member !== void 0; member = stack.pop()) {
+        onStack.delete(member);
+        component.add(member);
+        if (member === predicate) {
+          break;
+        }
+      }
+      for (const member of component) {
+        components.set(member, component);
+      }
+    }
+    return lowLink;
+  }
+  for (const predicate of next.keys()) {
+    if (!indices.has(predicate)) {
+      visit(predicate);
+    }
+  }
+  return components;
+}
 function isNegativeLiteral(value) {
   return typeof value === "object" && value !== null && "sign" in value && value.sign === "-" && "atom" in value && isAtomLike(value.atom);
 }
@@ -58,7 +148,7 @@ 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);
+  return isFormula(value) && [...ARITHMETIC_KINDS, "eq", "neq", "lt", "lte", "gt", "gte"].includes(value.kind);
 }
 function bindVariables(value, bound) {
   for (const variable of variablesIn(value)) {
@@ -177,7 +267,7 @@ function collectBodyEdgesWithKind(body, headPredicate, bound, edges, kind) {
 function assertConstructiveRecursion(context) {
   const edges = context.rules.flatMap(ruleEdges);
   const reachable = reachablePredicates(context.atom.predicate, edges);
-  const components = stronglyConnectedComponents(reachable, edges);
+  const components = componentsAmong(reachable, edges);
   const needsCandidateEnumeration = variablesIn(context.atom).length > 0;
   for (const component of components) {
     const internalEdges = edges.filter(
@@ -200,31 +290,22 @@ function assertConstructiveRecursion(context) {
 }
 function hasNonRecursiveBaseRule(component, rules) {
   return rules.some(
-    (rule) => component.has(rule.head.atom.predicate) && !bodyReferencesPredicates(rule.body, component)
+    (rule) => component.has(rule.head.atom.predicate) && hasNonRecursiveAlternative(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);
+function hasNonRecursiveAlternative(body, component) {
+  if (isFormula(body, "or")) {
+    return body.args.some((branch) => hasNonRecursiveAlternative(branch, component));
   }
-  return components;
+  return !bodyReferencesPredicates(body, component);
 }
-function reverseEdges(edges) {
-  return edges.map((edge) => ({ ...edge, from: edge.to, to: edge.from }));
+function componentsAmong(predicates, edges) {
+  const components = /* @__PURE__ */ new Set();
+  const byPredicate = stronglyConnectedComponents(edges);
+  for (const predicate of predicates) {
+    components.add(byPredicate.get(predicate) ?? /* @__PURE__ */ new Set([predicate]));
+  }
+  return [...components];
 }
 function bodyReferencesPredicates(body, predicates) {
   if (isAtomLike(body)) {
@@ -451,18 +532,17 @@ function groundAtom(atom, bindings) {
 var CandidateSearch = class {
   groups = /* @__PURE__ */ new Map();
   tables = /* @__PURE__ */ new Map();
+  evaluatingGroups = 0;
   constructor(rules) {
-    const edges = rules.flatMap(ruleEdges);
+    const components = stronglyConnectedComponents(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);
-        }
+      for (const member of components.get(predicate) ?? [predicate]) {
+        this.groups.set(member, group);
       }
     }
   }
@@ -491,6 +571,7 @@ var CandidateSearch = class {
     group.changed = true;
     if (!group.evaluating) {
       group.evaluating = true;
+      this.evaluatingGroups += 1;
       try {
         do {
           group.changed = false;
@@ -500,6 +581,7 @@ var CandidateSearch = class {
         } while (group.changed);
       } finally {
         group.evaluating = false;
+        this.evaluatingGroups -= 1;
       }
     }
     return [...table.atoms.values()];
@@ -507,8 +589,17 @@ var CandidateSearch = class {
   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);
+  /** A judgment depending on these predicates might observe a partial candidate table. */
+  evaluatingAmong(predicates) {
+    if (this.evaluatingGroups === 0) {
+      return false;
+    }
+    for (const predicate of predicates) {
+      if (this.groups.get(predicate)?.evaluating === true) {
+        return true;
+      }
+    }
+    return false;
   }
 };
 function expandTable(table) {
@@ -540,13 +631,88 @@ function patternKey(atom) {
   );
 }
 
+// src/solver/program-index.ts
+var ProgramIndex = class {
+  literals = /* @__PURE__ */ new Map();
+  rules = /* @__PURE__ */ new Map();
+  edges;
+  reachable = /* @__PURE__ */ new Map();
+  predicateIds = /* @__PURE__ */ new Map();
+  constructor(literals, rules) {
+    for (const literal of literals) {
+      const predicate = literal.atom.predicate;
+      const group = this.literals.get(predicate);
+      if (group === void 0) {
+        this.literals.set(predicate, [literal]);
+      } else {
+        group.push(literal);
+      }
+    }
+    for (const rule of rules) {
+      const predicate = rule.head.atom.predicate;
+      const group = this.rules.get(predicate);
+      if (group === void 0) {
+        this.rules.set(predicate, [rule]);
+      } else {
+        group.push(rule);
+      }
+    }
+    this.edges = rules.flatMap(ruleEdges);
+  }
+  literalsFor(predicate) {
+    return this.literals.get(predicate) ?? [];
+  }
+  rulesFor(predicate) {
+    return this.rules.get(predicate) ?? [];
+  }
+  /** Atom keys must distinguish declarations even when they share a display name. */
+  predicateId(predicate) {
+    let id = this.predicateIds.get(predicate);
+    if (id === void 0) {
+      id = this.predicateIds.size;
+      this.predicateIds.set(predicate, id);
+    }
+    return id;
+  }
+  reaches(predicate) {
+    let reachable = this.reachable.get(predicate);
+    if (reachable === void 0) {
+      reachable = reachablePredicates(predicate, this.edges);
+      this.reachable.set(predicate, reachable);
+    }
+    return reachable;
+  }
+};
+
 // src/solver/solve-all.ts
 var UNBOUND = /* @__PURE__ */ Symbol("factbag.unbound");
+function tabledComponents(literals, rules) {
+  const edges = rules.flatMap(ruleEdges);
+  const components = stronglyConnectedComponents(edges);
+  const selfRecursive = new Set(
+    edges.filter((edge) => edge.from === edge.to).map((edge) => edge.from)
+  );
+  const stated = new Set(literals.map((literal) => literal.atom.predicate));
+  const tabled = /* @__PURE__ */ new Map();
+  for (const component of new Set(components.values())) {
+    const members = [...component];
+    if (members.some((member) => member.world !== "closed" || stated.has(member)) || !(component.size > 1 || members.some((member) => selfRecursive.has(member)))) {
+      continue;
+    }
+    for (const member of members) {
+      tabled.set(member, component);
+    }
+  }
+  return tabled;
+}
 function solveQueryAll(literals, rules, atom) {
   validateQuery(literals, rules, atom);
-  const result = solveQueryAllInternal(literals, rules, atom, /* @__PURE__ */ new Set(), {
+  const result = solveQueryAllInternal(literals, rules, atom, /* @__PURE__ */ new Map(), {
     candidates: new CandidateSearch(rules),
-    judgments: /* @__PURE__ */ new Map()
+    judgments: /* @__PURE__ */ new Map(),
+    tabled: tabledComponents(literals, rules),
+    tables: /* @__PURE__ */ new Map(),
+    index: new ProgramIndex(literals, rules)
   });
   const stack = [result];
   const visited = /* @__PURE__ */ new Set();
@@ -584,7 +750,11 @@ function solveQueryAllInternal(literals, rules, atom, active, search) {
   );
 }
 function solveGroundAtom(literals, rules, atom, active, search) {
-  if (search.candidates.isEvaluating) {
+  if (search.tabled.has(atom.predicate)) {
+    return solveTabledAtom(literals, rules, atom, active, search);
+  }
+  const dependencies = search.index.reaches(atom.predicate);
+  if (search.candidates.evaluatingAmong(dependencies)) {
     return evaluateGroundAtom(literals, rules, atom, active, search);
   }
   let judgments = search.judgments.get(atom.predicate);
@@ -592,7 +762,8 @@ function solveGroundAtom(literals, rules, atom, active, search) {
     judgments = /* @__PURE__ */ new Map();
     search.judgments.set(atom.predicate, judgments);
   }
-  const key = JSON.stringify([groundAtomKey(atom), [...active].sort()]);
+  const relevantActive = [...active].filter(([, predicate]) => dependencies.has(predicate)).map(([key2]) => key2);
+  const key = JSON.stringify([groundAtomKey(atom, search), relevantActive.sort()]);
   const cached = judgments.get(key);
   if (cached !== void 0 && judgmentMatchesAtom(cached, atom)) {
     return cached;
@@ -604,12 +775,107 @@ function solveGroundAtom(literals, rules, atom, active, search) {
 function judgmentMatchesAtom(judgment, atom) {
   return atomEquals(judgment.goal.atom, atom);
 }
+function solveTabledAtom(literals, rules, atom, active, search) {
+  const table = tableFor(search, atom.predicate);
+  const key = groundAtomKey(atom, search);
+  const enter = () => {
+    const absent = {
+      value: "false",
+      goal: { kind: "atom", atom },
+      bindings: [],
+      negative: [{ source: "closed-world-absence" }]
+    };
+    table.judgments.set(key, absent);
+    table.atoms.set(key, atom);
+    table.queue.push(key);
+    table.queued.add(key);
+    return absent;
+  };
+  if (table.running) {
+    const judgment = table.judgments.get(key) ?? enter();
+    if (table.evaluating !== void 0) {
+      let dependents = table.dependents.get(key);
+      if (dependents === void 0) {
+        dependents = /* @__PURE__ */ new Set();
+        table.dependents.set(key, dependents);
+      }
+      dependents.add(table.evaluating);
+    }
+    assert(judgmentMatchesAtom(judgment, atom), "Tabled judgment must match its atom");
+    return judgment;
+  }
+  const settled = table.judgments.get(key);
+  if (settled !== void 0) {
+    assert(judgmentMatchesAtom(settled, atom), "Tabled judgment must match its atom");
+    return settled;
+  }
+  enter();
+  table.running = true;
+  try {
+    for (let offset = 0; offset < table.queue.length; offset += 1) {
+      const next = table.queue[offset];
+      assert(next !== void 0, "Queued atom must have a key");
+      table.queued.delete(next);
+      const current = table.judgments.get(next);
+      const subject = table.atoms.get(next);
+      assert(current !== void 0 && subject !== void 0, "Queued atom must be in the table");
+      table.evaluating = next;
+      const judged = evaluateGroundAtom(literals, rules, subject, active, search);
+      table.evaluating = void 0;
+      table.judgments.set(next, judged);
+      if (judged.value === current.value) {
+        continue;
+      }
+      assert(
+        maxGoalValue(current.value, judged.value) === judged.value,
+        "Tabled recursion must be monotone"
+      );
+      const changes = (table.changes.get(next) ?? 0) + 1;
+      assert(changes <= 3, "Tabled recursion did not converge");
+      table.changes.set(next, changes);
+      for (const dependent of table.dependents.get(next) ?? []) {
+        if (!table.queued.has(dependent)) {
+          table.queue.push(dependent);
+          table.queued.add(dependent);
+        }
+      }
+    }
+    table.queue.length = 0;
+  } finally {
+    table.running = false;
+    table.evaluating = void 0;
+  }
+  const result = table.judgments.get(key);
+  assert(result !== void 0 && judgmentMatchesAtom(result, atom), "Run must judge its seed");
+  return result;
+}
+function tableFor(search, predicate) {
+  let table = search.tables.get(predicate);
+  if (table === void 0) {
+    const component = search.tabled.get(predicate);
+    assert(component !== void 0, "Only a tabled predicate has a table");
+    table = {
+      judgments: /* @__PURE__ */ new Map(),
+      atoms: /* @__PURE__ */ new Map(),
+      dependents: /* @__PURE__ */ new Map(),
+      changes: /* @__PURE__ */ new Map(),
+      queue: [],
+      queued: /* @__PURE__ */ new Set(),
+      running: false,
+      evaluating: void 0
+    };
+    for (const member of component) {
+      search.tables.set(member, table);
+    }
+  }
+  return table;
+}
 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 atomKey = groundAtomKey(atom, search);
+  const positiveLiterals = matchingLiterals(search.index.literalsFor(atom.predicate), atom, "+");
+  const negativeLiterals = matchingLiterals(search.index.literalsFor(atom.predicate), atom, "-");
   const values = [];
   const positive = [];
   const negative = [];
@@ -622,9 +888,9 @@ function evaluateGroundAtom(literals, rules, atom, active, search) {
     values.push("false");
   }
   if (!active.has(atomKey)) {
-    const nextActive = new Set(active);
-    nextActive.add(atomKey);
-    for (const rule of rules) {
+    const nextActive = new Map(active);
+    nextActive.set(atomKey, atom.predicate);
+    for (const rule of search.index.rulesFor(atom.predicate)) {
       const match = matchRuleForAtom(rule, atom);
       if (match === void 0) {
         continue;
@@ -760,7 +1026,10 @@ function evaluateRuleBodyMany(literals, rules, body, bindings, active, context,
       ];
     }
     const atom = groundAtom(bodyAtom, bindings);
-    assert(!active.has(groundAtomKey(atom)), "Validated query must not recurse through negation");
+    assert(
+      !active.has(groundAtomKey(atom, context.search)),
+      "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);
@@ -1070,8 +1339,15 @@ function evaluateAtomBody(literals, rules, atom, bindings, active, context, path
 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 allowsEntities = kind === "eq" || kind === "neq";
+  assert(
+    isScalarGoalExpression(left.expression) || allowsEntities && isEntityValue(left.expression),
+    "Left comparison operand must be scalar, or entity for equality"
+  );
+  assert(
+    isScalarGoalExpression(right.expression) || allowsEntities && isEntityValue(right.expression),
+    "Right comparison operand must be scalar, or entity for equality"
+  );
   const nextBindings = right.bindings;
   const judgmentBindings = bindingsArray(nextBindings);
   const goal = {
@@ -1645,7 +1921,7 @@ function primitiveRangeForExact(value) {
   return { range: { lower: value, upper: value } };
 }
 function isArithmeticFormula(value) {
-  return isFormula(value) && ["add", "sub", "mul", "div"].includes(value.kind) && value.args.length === 2;
+  return isFormula(value) && ARITHMETIC_KINDS.some((kind) => kind === 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;
@@ -1663,18 +1939,17 @@ 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 (left instanceof Date && right instanceof Date) {
+    if (kind === "daysBetween") {
+      return daysBetween(left, right);
+    }
+    if (kind === "yearsBetween") {
+      return yearsBetween(left, right);
     }
   }
+  if (left instanceof Date && typeof right === "number" && kind === "sub") {
+    return new Date(left.getTime() - right);
+  }
   if (typeof left === "number" && typeof right === "number") {
     switch (kind) {
       case "add":
@@ -1685,12 +1960,67 @@ function calculateValue(kind, left, right, goal) {
         return left * right;
       case "div":
         return left / right;
+      case "daysBetween":
+      case "yearsBetween":
+        break;
+      case "min":
+        return Math.min(left, right);
+      case "max":
+        return Math.max(left, right);
+      case "roundTo":
+      case "floorTo":
+      case "ceilTo":
+        if (!Number.isInteger(right)) {
+          throw new PrimitiveArithmeticProgrammerError(kind, [left, right], goal);
+        }
+        return roundAtPlaces(left, right, kind);
       default:
         return assertNever(kind, "Unhandled arithmetic kind");
     }
   }
   throw new PrimitiveArithmeticProgrammerError(kind, [left, right], goal);
 }
+function shiftDecimal(value, places) {
+  if (value === 0 || !Number.isFinite(value)) {
+    return value;
+  }
+  const [coefficient, exponent = "0"] = String(value).split("e");
+  const shiftedExponent = Number(exponent) + places;
+  if (shiftedExponent > 308) {
+    return Math.sign(value) * Infinity;
+  }
+  if (shiftedExponent < -324) {
+    return Math.sign(value) * 0;
+  }
+  return Number(`${coefficient}e${shiftedExponent}`);
+}
+function roundAtPlaces(value, places, kind) {
+  if (value === 0 || !Number.isFinite(value)) {
+    return value;
+  }
+  let shifted = shiftDecimal(value, places);
+  if (!Number.isFinite(shifted)) {
+    return value;
+  }
+  if (shifted === 0) {
+    shifted = Math.sign(value) * Number.MIN_VALUE;
+  }
+  let rounded;
+  switch (kind) {
+    case "roundTo":
+      rounded = Math.sign(shifted) * Math.round(Math.abs(shifted));
+      break;
+    case "floorTo":
+      rounded = Math.floor(shifted);
+      break;
+    case "ceilTo":
+      rounded = Math.ceil(shifted);
+      break;
+    default:
+      return assertNever(kind, "Unhandled rounding kind");
+  }
+  return shiftDecimal(rounded, -places);
+}
 function compareValues(kind, left, right) {
   assert(left !== UNBOUND && right !== UNBOUND, "Comparison operands must be bound");
   if (isNumericRangeValue(left) && typeof right === "number") {
@@ -1703,9 +2033,9 @@ function compareValues(kind, left, right) {
   const rightComparable = right instanceof Date ? right.getTime() : right;
   switch (kind) {
     case "eq":
-      return leftComparable === rightComparable ? "true" : "false";
+      return sameValue(leftComparable, rightComparable) ? "true" : "false";
     case "neq":
-      return leftComparable === rightComparable ? "false" : "true";
+      return sameValue(leftComparable, rightComparable) ? "false" : "true";
     case "lt":
     case "lte":
     case "gt":
@@ -1715,6 +2045,15 @@ function compareValues(kind, left, right) {
       return assertNever(kind, "Unhandled comparison kind");
   }
 }
+function sameValue(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (isEntityValue(left) && isEntityValue(right)) {
+    return JSON.stringify(fieldIdentityToken(left)) === JSON.stringify(fieldIdentityToken(right));
+  }
+  return false;
+}
 function compareOrderedValues(kind, left, right) {
   assert(typeof left === "number" && typeof right === "number", "Values must be comparable");
   switch (kind) {
@@ -1918,14 +2257,14 @@ function uniqueBindings(bindings) {
 function canGroundAtom(atom, bindings) {
   return Object.values(atom.fields).every((value) => !isVar(value) || bindings.has(value));
 }
-function groundAtomKey(atom) {
+function groundAtomKey(atom, search) {
   const fields = atom.predicate.paramNames.map((name) => fieldIdentityToken(atom.fields[name]));
-  return `${atom.predicate.name}:${JSON.stringify(fields)}`;
+  return `${search.index.predicateId(atom.predicate)}:${JSON.stringify(fields)}`;
 }
 function candidateGroundAtoms(literals, rules, atom, active, search, pathCanHaveUnavailableBindings = false) {
   return search.candidates.candidates(
     atom,
-    matchingGroundAtoms(literals, atom),
+    matchingGroundAtoms(search.index.literalsFor(atom.predicate), atom),
     () => deriveCandidateAtoms(literals, rules, atom, active, search, pathCanHaveUnavailableBindings)
   ).filter(
     (candidate) => isAtomForPredicate(candidate, atom.predicate)
@@ -1933,7 +2272,7 @@ function candidateGroundAtoms(literals, rules, atom, active, search, pathCanHave
 }
 function deriveCandidateAtoms(literals, rules, atom, active, search, pathCanHaveUnavailableBindings = false) {
   const atoms = [];
-  for (const rule of rules) {
+  for (const rule of search.index.rulesFor(atom.predicate)) {
     const ruleHead = atomForPredicate(rule.head.atom, atom.predicate);
     if (ruleHead === void 0) {
       continue;

package/dist/core/solver/calendar.d.ts

@@ -0,0 +1,4 @@
+/** Signed UTC calendar days from `earlier` to `later`, ignoring time of day. */
+export declare function daysBetween(later: Date, earlier: Date): number;
+/** Whole UTC anniversary years, with February 29 anniversaries on March 1 in common years. */
+export declare function yearsBetween(later: Date, earlier: Date): number;