factbag 0.0.0-alpha.2 → 0.0.0-alpha.3

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # factbag
 
+## 0.0.0-alpha.3
+
+### Minor Changes
+
+- f8f2712: Add `eq` and `neq` rule-body comparisons for numbers, dates, strings, booleans, and entities. Entities compare by type and id rather than instance; dates compare by instant.
+- 900b104: Add min, max, roundTo, floorTo, and ceilTo numeric arithmetic terms for rule bodies. Rounding supports whole-number decimal places (including negative places), with halves rounded away from zero. Decimal exponent shifting avoids multiplication artifacts at decimal rounding boundaries.
+- 4f040e3: Add `daysBetween(later, earlier)` and `yearsBetween(later, earlier)` as number-valued arithmetic terms over dates. They count signed UTC calendar days and whole anniversary years, ignoring time of day; February 29 anniversaries fall on March 1 in common years. Numeric subtraction on variables now composes with other numeric operators.
+
+### Patch Changes
+
+- 01cc338: Speed up queries over large rulesets with linear-time recursive predicate grouping,
+  per-query rule and evidence indexes, and judgment reuse during candidate discovery.
+  Preserve candidate pruning and distinguish same-named predicate declarations when
+  tracking active atoms, avoiding incorrect recursion cutoffs.
+- 80d1e75: Share explanation nodes for reused proof judgments so explanation construction no longer grows with the number of paths through a shared proof. Identical sub-explanations are still listed once, and rendered content is unchanged.
+- a074dab: Judge evidence-free, closed-world recursive components together as a least fixed
+  point instead of enumerating recursive proof paths. Doubly recursive transitive
+  closures and symmetric compositions no longer require exponential proof search.
+  Other components retain the existing search semantics. Variable queries recognize
+  a non-recursive disjunctive base case within an exclusive definition.
+
 ## 0.0.0-alpha.2
 
 ### Major Changes

package/dist/core/{chunk-X3LSDJL4.js → chunk-QOMFY3XB.js}

@@ -13,7 +13,10 @@ var PrimitiveArithmeticProgrammerError = class extends ProgrammerError {
   /** The arithmetic goal being evaluated when the failure occurred. */
   goal;
   constructor(operation, operands, goal) {
-    super(`${operation} expected numeric operands`);
+    const rounding = operation === "roundTo" || operation === "floorTo" || operation === "ceilTo";
+    super(
+      `${operation} expected ${operation === "daysBetween" || operation === "yearsBetween" ? "date" : "numeric"} operands${rounding ? " and a whole number of decimal places" : ""}`
+    );
     this.name = "PrimitiveArithmeticProgrammerError";
     this.operation = operation;
     this.operands = operands;

package/dist/core/{chunk-5J3WGMN2.js → chunk-RMQ3YX7V.js}

@@ -82,5 +82,6 @@ export {
   isAtomForPredicate,
   atomEquals,
   fieldEquals,
-  fieldIdentityToken
+  fieldIdentityToken,
+  isEntityValue
 };

package/dist/core/dsl/index.d.ts

@@ -6,9 +6,9 @@
  */
 export { and, exists, letIn, not, or } from "./formula.js";
 export { count, sum } from "./operators/aggregate.js";
-export type { AggregateBuilder, ComparableTerm, DateTerm, NumericTerm } from "./types.js";
-export { add, div, mul, sub } from "./operators/arithmetic.js";
-export { gt, gte, lte } from "./operators/comparison.js";
+export type { AggregateBuilder, ComparableTerm, DateTerm, EqualityTerm, NumericTerm, } from "./types.js";
+export { add, ceilTo, daysBetween, div, floorTo, max, min, mul, roundTo, sub, yearsBetween, } from "./operators/arithmetic.js";
+export { eq, gt, gte, lte, neq } from "./operators/comparison.js";
 export { closedPredicate, predicate } from "./predicate.js";
 export { enumeration } from "./enumeration.js";
 export type { ClosedWorldPredicate, OpenWorldPredicate, Predicate, PredicateBase, PredicateDeclaration, PredicateMetadata, PredicateWorld, } from "../types/predicate.js";

package/dist/core/dsl/index.js

@@ -1,7 +1,7 @@
 import {
   assertAtomLike,
   assertGroundAtom
-} from "../chunk-5J3WGMN2.js";
+} from "../chunk-RMQ3YX7V.js";
 import {
   Var
 } from "../chunk-UVOCOH2I.js";
@@ -68,8 +68,53 @@ function div(left, right) {
   assertSupportedValue(right);
   return { kind: "div", args: [left, right] };
 }
+function daysBetween(later, earlier) {
+  assertSupportedValue(later);
+  assertSupportedValue(earlier);
+  return { kind: "daysBetween", args: [later, earlier] };
+}
+function yearsBetween(later, earlier) {
+  assertSupportedValue(later);
+  assertSupportedValue(earlier);
+  return { kind: "yearsBetween", args: [later, earlier] };
+}
+function min(left, right) {
+  assertSupportedValue(left);
+  assertSupportedValue(right);
+  return { kind: "min", args: [left, right] };
+}
+function max(left, right) {
+  assertSupportedValue(left);
+  assertSupportedValue(right);
+  return { kind: "max", args: [left, right] };
+}
+function roundTo(value, places) {
+  assertSupportedValue(value);
+  assertSupportedValue(places);
+  return { kind: "roundTo", args: [value, places] };
+}
+function floorTo(value, places) {
+  assertSupportedValue(value);
+  assertSupportedValue(places);
+  return { kind: "floorTo", args: [value, places] };
+}
+function ceilTo(value, places) {
+  assertSupportedValue(value);
+  assertSupportedValue(places);
+  return { kind: "ceilTo", args: [value, places] };
+}
 
 // src/dsl/operators/comparison.ts
+function eq(left, right) {
+  assertSupportedValue(left);
+  assertSupportedValue(right);
+  return { kind: "eq", args: [left, right] };
+}
+function neq(left, right) {
+  assertSupportedValue(left);
+  assertSupportedValue(right);
+  return { kind: "neq", args: [left, right] };
+}
 function gt(left, right) {
   assertSupportedValue(left);
   assertSupportedValue(right);
@@ -138,20 +183,29 @@ export {
   and,
   assertAtomLike,
   assertGroundAtom,
+  ceilTo,
   closedPredicate,
   count,
+  daysBetween,
   div,
   enumeration,
+  eq,
   exists,
+  floorTo,
   gt,
   gte,
   letIn,
   lte,
+  max,
+  min,
   mul,
+  neq,
   not,
   or,
   predicate,
+  roundTo,
   sub,
   sum,
-  variable
+  variable,
+  yearsBetween
 };

package/dist/core/dsl/operators/arithmetic.d.ts

@@ -1,6 +1,8 @@
 import type { DateTerm, Formula, NumericTerm } from "../types.js";
 /** Add two numeric terms, producing a numeric rule-body expression. */
 export declare function add(left: NumericTerm, right: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
+/** Subtract one numeric term from another. */
+export declare function sub(left: NumericTerm, right: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
 /**
  * Subtract a numeric duration in milliseconds from a date term, producing a
  * date expression.
@@ -19,9 +21,74 @@ export declare function add(left: NumericTerm, right: NumericTerm): Formula<numb
  * ```
  */
 export declare function sub(left: DateTerm, right: NumericTerm): Formula<Date, readonly [DateTerm, NumericTerm]>;
-/** Subtract one numeric term from another. */
-export declare function sub(left: NumericTerm, right: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
 /** Multiply two numeric terms, producing a numeric rule-body expression. */
 export declare function mul(left: NumericTerm, right: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
 /** Divide one numeric term by another, producing a numeric rule-body expression. */
 export declare function div(left: NumericTerm, right: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
+/**
+ * Count signed UTC calendar days from `earlier` to `later`, ignoring time of day.
+ * Add one to count both the first and last day of a stay.
+ */
+export declare function daysBetween(later: DateTerm, earlier: DateTerm): Formula<number, readonly [DateTerm, DateTerm]>;
+/**
+ * Count signed whole years from `earlier` to `later` by UTC calendar anniversaries,
+ * ignoring time of day. February 29 anniversaries fall on March 1 in common years.
+ * A person's age on a day is `yearsBetween(day, birthday)`.
+ */
+export declare function yearsBetween(later: DateTerm, earlier: DateTerm): Formula<number, readonly [DateTerm, DateTerm]>;
+/**
+ * The lesser of two numeric terms.
+ *
+ * @example
+ * ```ts
+ * // Deduction reduction cannot exceed 80% of the deductions.
+ * letIn(R, min(mul(0.03, Excess), mul(0.8, Deductions)), gte(R, 0))
+ * ```
+ */
+export declare function min(left: NumericTerm, right: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
+/**
+ * The greater of two numeric terms.
+ *
+ * @example
+ * ```ts
+ * // The remaining allowance cannot be negative.
+ * letIn(A, max(sub(2000, Reduction), 0), gte(A, 0))
+ * ```
+ */
+export declare function max(left: NumericTerm, right: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
+/**
+ * Round to a whole number of decimal places, with halves away from zero.
+ * Negative places round to tens, hundreds, and so on. Decimal exponent shifting
+ * avoids multiplication artifacts such as `1.005 * 100`, so `roundTo(1.005, 2)`
+ * yields `1.01`. Inputs and results still have JavaScript number precision;
+ * this does not recover precision already lost in an earlier expression.
+ *
+ * @example
+ * ```ts
+ * // Tax is 15% of taxable income, in whole dollars.
+ * letIn(Tax, roundTo(mul(Income, 0.15), 0), gte(Tax, 0))
+ * ```
+ */
+export declare function roundTo(value: NumericTerm, places: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
+/**
+ * Round toward negative infinity at a whole number of decimal places.
+ * Negative places and decimal exponent shifting work as in {@link roundTo}.
+ *
+ * @example
+ * ```ts
+ * // Only complete thousands of eligible expenses count.
+ * letIn(Eligible, floorTo(Expenses, -3), gte(Eligible, 0))
+ * ```
+ */
+export declare function floorTo(value: NumericTerm, places: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;
+/**
+ * Round toward positive infinity at a whole number of decimal places.
+ * Negative places and decimal exponent shifting work as in {@link roundTo}.
+ *
+ * @example
+ * ```ts
+ * // Two percentage points for each $2,500, or fraction thereof, of the excess.
+ * letIn(Points, mul(2, ceilTo(div(Excess, 2500), 0)), lte(Points, 100))
+ * ```
+ */
+export declare function ceilTo(value: NumericTerm, places: NumericTerm): Formula<number, readonly [NumericTerm, NumericTerm]>;

package/dist/core/dsl/operators/comparison.d.ts

@@ -1,4 +1,14 @@
-import type { ComparableTerm, Formula } from "../types.js";
+import type { ComparableTerm, EqualityTerm, Formula } from "../types.js";
+/**
+ * Require equal values: numbers, strings, and booleans by value, dates by instant,
+ * and entities by type and id rather than instance.
+ *
+ * @remarks
+ * Comparisons gate whether a rule fires but contribute no proof children.
+ */
+export declare function eq(left: EqualityTerm, right: EqualityTerm): Formula<boolean, readonly [EqualityTerm, EqualityTerm]>;
+/** Require the two terms to differ, in the sense of {@link eq}. */
+export declare function neq(left: EqualityTerm, right: EqualityTerm): Formula<boolean, readonly [EqualityTerm, EqualityTerm]>;
 /**
  * Require the left term to be strictly greater than the right.
  *

package/dist/core/dsl/types.d.ts

@@ -44,6 +44,8 @@ export type NumericTerm = number | Var | Formula<number, readonly unknown[]>;
 export type DateTerm = Date | Var | Formula<Date, readonly unknown[]>;
 /** Term accepted by comparison helpers. */
 export type ComparableTerm = NumericTerm | DateTerm;
+/** Term accepted by equality: a comparable term, a string, a boolean, or an entity. */
+export type EqualityTerm = ComparableTerm | string | boolean | Entity;
 /** Aggregate builder returned by sum(...) and count(...). */
 export type AggregateBuilder<Value extends number = number> = Readonly<{
     where: (<const Body>(body: Body & RuleBodyInput<Body>) => Formula<Value, readonly [Body]>) & (<const Body, const CompleteWhen>(body: Body & RuleBodyInput<Body>, options: Readonly<{

package/dist/core/exceptions/programmer-errors.d.ts

@@ -1,4 +1,4 @@
-import type { ArithmeticGoal } from "../types/goal.js";
+import type { ArithmeticGoal, ArithmeticKind } from "../types/goal.js";
 import type { PredicateDeclaration } from "../types/predicate.js";
 import type { AnyRule } from "../types/rule.js";
 import type { Var } from "../types/variable.js";
@@ -9,12 +9,12 @@ export declare class ProgrammerError extends Error {
 /** Arithmetic primitive with operands the solver cannot legally evaluate. */
 export declare class PrimitiveArithmeticProgrammerError extends ProgrammerError {
     /** The arithmetic operation that failed. */
-    readonly operation: "add" | "sub" | "mul" | "div";
+    readonly operation: ArithmeticKind;
     /** The evaluated left and right operand values. */
     readonly operands: readonly [unknown, unknown];
     /** The arithmetic goal being evaluated when the failure occurred. */
-    readonly goal: ArithmeticGoal<"add" | "sub" | "mul" | "div">;
-    constructor(operation: "add" | "sub" | "mul" | "div", operands: readonly [unknown, unknown], goal: ArithmeticGoal<"add" | "sub" | "mul" | "div">);
+    readonly goal: ArithmeticGoal<ArithmeticKind>;
+    constructor(operation: ArithmeticKind, operands: readonly [unknown, unknown], goal: ArithmeticGoal<ArithmeticKind>);
 }
 /** Rule body uses variables before any constructive source can bind them. */
 export declare class UnsafeUnboundVariableProgrammerError extends ProgrammerError {

package/dist/core/explanation/explain.d.ts

@@ -1,9 +1,13 @@
 import type { Judgment } from "../types/judgment.js";
 import type { Explanation } from "./types.js";
 /**
- * Convert a judgment's proof-support tree into a compact, LLM-readable
+ * Convert a judgment's proof-support graph into a compact, LLM-readable
  * {@link Explanation} of what was concluded and why.
  *
+ * The result is a directed acyclic graph (DAG): reused judgment objects share
+ * explanation nodes within this call. Serializing the result as JSON still
+ * expands shared nodes at every path to them.
+ *
  * @example
  * ```ts
  * const explanation = explainJudgment(query(kb, doctor({ person: alice })));

package/dist/core/explanation/index.js

@@ -1,6 +1,6 @@
 import {
   isFormula
-} from "../chunk-A6ZZJWIO.js";
+} from "../chunk-NDUIQAH4.js";
 import {
   AssertionError,
   isVar
@@ -8,6 +8,21 @@ import {
 
 // src/explanation/explain.ts
 function explainJudgment(judgment) {
+  return explainWithContext(judgment, {
+    explanations: /* @__PURE__ */ new WeakMap(),
+    contentKeys: /* @__PURE__ */ new WeakMap(),
+    keyIds: /* @__PURE__ */ new Map()
+  });
+}
+function explainWithContext(judgment, context) {
+  let explanation = context.explanations.get(judgment);
+  if (explanation === void 0) {
+    explanation = explainOnce(judgment, context);
+    context.explanations.set(judgment, explanation);
+  }
+  return explanation;
+}
+function explainOnce(judgment, context) {
   if (isClosedWorldAbsence(judgment)) {
     const atom = judgment.goal.goal.atom;
     return {
@@ -21,7 +36,7 @@ function explainJudgment(judgment) {
     return {
       claim: claimForJudgment(judgment),
       because: formatRuleApplication(ruleSupport.rule, ruleSupport.body.bindings),
-      given: [explainJudgment(ruleSupport.body)]
+      given: [explainWithContext(ruleSupport.body, context)]
     };
   }
   const evidence = supports.flatMap(
@@ -41,7 +56,10 @@ function explainJudgment(judgment) {
   if (subgoals.length > 0) {
     return {
       claim: claimForJudgment(judgment),
-      given: uniqueExplanations(subgoals.map(explainJudgment))
+      given: uniqueExplanations(
+        subgoals.map((subgoal) => explainWithContext(subgoal, context)),
+        context
+      )
     };
   }
   const closedWorldAbsence = supports.find((support) => support.source === "closed-world-absence");
@@ -56,11 +74,11 @@ function explainJudgment(judgment) {
     because: "no supporting evidence or rule was found"
   };
 }
-function uniqueExplanations(explanations) {
+function uniqueExplanations(explanations, context) {
   const seen = /* @__PURE__ */ new Set();
   const unique = [];
   for (const explanation of explanations) {
-    const key = JSON.stringify(explanation);
+    const key = contentKey(explanation, context);
     if (!seen.has(key)) {
       seen.add(key);
       unique.push(explanation);
@@ -68,6 +86,21 @@ function uniqueExplanations(explanations) {
   }
   return unique;
 }
+function contentKey(explanation, context) {
+  let id = context.contentKeys.get(explanation);
+  if (id === void 0) {
+    const given = "given" in explanation ? explanation.given.map((child) => contentKey(child, context)) : void 0;
+    const because = "because" in explanation ? explanation.because : void 0;
+    const key = JSON.stringify([explanation.claim, because, given]);
+    id = context.keyIds.get(key);
+    if (id === void 0) {
+      id = context.keyIds.size;
+      context.keyIds.set(key, id);
+    }
+    context.contentKeys.set(explanation, id);
+  }
+  return id;
+}
 function supportsForValue(judgment) {
   if (judgment.value === "true") {
     return judgment.positive;
@@ -144,6 +177,13 @@ function formatGoal(goal) {
     case "sub":
     case "mul":
     case "div":
+    case "daysBetween":
+    case "yearsBetween":
+    case "min":
+    case "max":
+    case "roundTo":
+    case "floorTo":
+    case "ceilTo":
       return `${goal.bind.name} = ${goal.kind}(${formatValue(goal.left)}, ${formatValue(goal.right)})`;
     case "eq":
     case "neq":

package/dist/core/knowledge-base/index.js

@@ -3,10 +3,10 @@ import {
   PrimitiveArithmeticProgrammerError,
   ProgrammerError,
   UnsafeUnboundVariableProgrammerError
-} from "../chunk-X3LSDJL4.js";
+} from "../chunk-QOMFY3XB.js";
 import {
   isAtomLike
-} from "../chunk-5J3WGMN2.js";
+} from "../chunk-RMQ3YX7V.js";
 import "../chunk-UVOCOH2I.js";
 
 // src/knowledge-base/assertions/exclusive-definitions.ts

package/dist/core/query/index.d.ts

@@ -6,5 +6,5 @@
  */
 export { query, queryAll } from "./query.js";
 export type { Binding, Bindings, GoalValue } from "../types/common.js";
-export type { AddGoal, AndGoal, AnyAtomGoal, ArithmeticGoal, AtomGoal, ComparisonGoal, CompoundGoal, CountGoal, DivGoal, EqGoal, ExistsGoal, Goal, GoalExpression, GroundAtomGoal, GtGoal, GteGoal, LetGoal, LtGoal, LteGoal, MulGoal, NeqGoal, NotGoal, OrGoal, PrimitiveGoal, SubGoal, SumGoal, } from "../types/goal.js";
+export type { AddGoal, AndGoal, AnyAtomGoal, ArithmeticGoal, ArithmeticKind, AtomGoal, CeilToGoal, ComparisonGoal, CompoundGoal, CountGoal, DaysBetweenGoal, DivGoal, EqGoal, ExistsGoal, FloorToGoal, Goal, GoalExpression, GroundAtomGoal, GtGoal, GteGoal, LetGoal, LtGoal, LteGoal, MaxGoal, MinGoal, MulGoal, NeqGoal, NotGoal, OrGoal, PrimitiveGoal, RoundToGoal, SubGoal, SumGoal, YearsBetweenGoal, } from "../types/goal.js";
 export type { ArithmeticPrimitiveSupport, ClosedWorldAbsenceSupport, ComparisonPrimitiveSupport, CountPrimitiveSupport, ErasedEvidenceSupport, ErasedRuleSupport, EvidenceSupport, Judgment, JudgmentBase, JudgmentSupportFor, MissingBinding, NumericRange, PrimitiveEvaluation, PrimitiveSupport, PrimitiveSupportFor, PrimitiveUncertainty, QueryAllJudgment, QueryJudgment, RuleSupport, SubgoalsSupport, SumPrimitiveSupport, } from "../types/judgment.js";

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-RMQ3YX7V.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;

package/dist/core/solver/candidate-search.d.ts

@@ -5,8 +5,10 @@ import type { AnyRule } from "../types/rule.js";
 export declare class CandidateSearch {
     private readonly groups;
     private readonly tables;
+    private evaluatingGroups;
     constructor(rules: readonly AnyRule[]);
     candidates(atom: Atom, seeds: readonly GroundAtom[], derive: () => readonly GroundAtom[]): GroundAtom[];
     sameComponent(left: PredicateDeclaration, right: PredicateDeclaration): boolean;
-    get isEvaluating(): boolean;
+    /** A judgment depending on these predicates might observe a partial candidate table. */
+    evaluatingAmong(predicates: Iterable<PredicateDeclaration>): boolean;
 }

package/dist/core/solver/program-index.d.ts

@@ -0,0 +1,17 @@
+import type { AnyLiteral } from "../types/literal.js";
+import type { PredicateDeclaration } from "../types/predicate.js";
+import type { AnyRule } from "../types/rule.js";
+/** Query-local lookups; predicate identity, not its name, determines dependencies. */
+export declare class ProgramIndex {
+    private readonly literals;
+    private readonly rules;
+    private readonly edges;
+    private readonly reachable;
+    private readonly predicateIds;
+    constructor(literals: readonly AnyLiteral[], rules: readonly AnyRule[]);
+    literalsFor(predicate: PredicateDeclaration): readonly AnyLiteral[];
+    rulesFor(predicate: PredicateDeclaration): readonly AnyRule[];
+    /** Atom keys must distinguish declarations even when they share a display name. */
+    predicateId(predicate: PredicateDeclaration): number;
+    reaches(predicate: PredicateDeclaration): ReadonlySet<PredicateDeclaration>;
+}

package/dist/core/solver/query-validation/utils.d.ts

@@ -10,6 +10,8 @@ export type Edge = Readonly<{
 }>;
 export declare function ruleEdges(rule: AnyRule): Edge[];
 export declare function reachablePredicates(start: PredicateDeclaration, edges: readonly Edge[]): Set<PredicateDeclaration>;
+/** Linear-time Tarjan components, including predicates that occur only as targets. */
+export declare function stronglyConnectedComponents(edges: readonly Edge[]): ReadonlyMap<PredicateDeclaration, ReadonlySet<PredicateDeclaration>>;
 export declare function isNegativeLiteral(value: unknown): value is AnyLiteral & {
     sign: "-";
 };

package/dist/core/types/atom.d.ts

@@ -1,4 +1,4 @@
-import type { InferRuntime, PredicateSchema } from "./schema.js";
+import type { Entity, InferRuntime, PredicateSchema } from "./schema.js";
 import type { Var } from "./variable.js";
 import type { PredicateDeclaration } from "./predicate.js";
 /** An atom whose exact schema has been intentionally erased. */
@@ -52,4 +52,9 @@ export declare function atomEquals(left: AnyAtom, right: AnyAtom): boolean;
 export declare function fieldEquals(left: unknown, right: unknown): boolean;
 /** Canonical JSON-safe token for a field value, for use in string identity keys. */
 export declare function fieldIdentityToken(value: unknown): unknown;
+export declare function isEntityValue(value: unknown): value is Entity & {
+    constructor: {
+        name: string;
+    };
+};
 export {};

package/dist/core/types/goal.d.ts

@@ -55,8 +55,26 @@ export type SubGoal = ArithmeticGoal<"sub">;
 export type MulGoal = ArithmeticGoal<"mul">;
 /** Arithmetic goal binding the quotient of two expressions. */
 export type DivGoal = ArithmeticGoal<"div">;
+/** Arithmetic goal binding the UTC calendar days from the right date to the left. */
+export type DaysBetweenGoal = ArithmeticGoal<"daysBetween">;
+/** Arithmetic goal binding whole anniversary years from the right date to the left. */
+export type YearsBetweenGoal = ArithmeticGoal<"yearsBetween">;
+/** Arithmetic goal binding the lesser of two numeric expressions. */
+export type MinGoal = ArithmeticGoal<"min">;
+/** Arithmetic goal binding the greater of two numeric expressions. */
+export type MaxGoal = ArithmeticGoal<"max">;
+/** Arithmetic goal rounding halves away from zero at the right operand's decimal places. */
+export type RoundToGoal = ArithmeticGoal<"roundTo">;
+/** Arithmetic goal rounding toward negative infinity at the right operand's decimal places. */
+export type FloorToGoal = ArithmeticGoal<"floorTo">;
+/** Arithmetic goal rounding toward positive infinity at the right operand's decimal places. */
+export type CeilToGoal = ArithmeticGoal<"ceilTo">;
+/** The primitive arithmetic operations. */
+export type ArithmeticKind = "add" | "sub" | "mul" | "div" | "daysBetween" | "yearsBetween" | "min" | "max" | "roundTo" | "floorTo" | "ceilTo";
+/** Shared runtime classification for arithmetic formulas. */
+export declare const ARITHMETIC_KINDS: readonly ArithmeticKind[];
 /** Bind the result of a primitive arithmetic operation. */
-export type ArithmeticGoal<Kind extends "add" | "sub" | "mul" | "div"> = Readonly<{
+export type ArithmeticGoal<Kind extends ArithmeticKind> = Readonly<{
     readonly kind: Kind;
     readonly bind: Var;
     readonly left: GoalExpression<Scalar>;
@@ -77,8 +95,8 @@ export type GteGoal = ComparisonGoal<"gte">;
 /** Compare two value-producing expressions. */
 export type ComparisonGoal<Kind extends "eq" | "neq" | "lt" | "lte" | "gt" | "gte"> = Readonly<{
     readonly kind: Kind;
-    readonly left: GoalExpression<Scalar>;
-    readonly right: GoalExpression<Scalar>;
+    readonly left: GoalExpression;
+    readonly right: GoalExpression;
 }>;
 /** Sum a numeric expression over rows matched by a body goal. */
 export type SumGoal = Readonly<{
@@ -96,8 +114,8 @@ export type CountGoal = Readonly<{
     readonly completeWhen?: Goal;
 }>;
 /** A normalized rule-body target that the solver/proof system can evaluate. */
-export type Goal = AnyAtomGoal | NotGoal | AndGoal | OrGoal | ExistsGoal | LetGoal | AddGoal | SubGoal | MulGoal | DivGoal | EqGoal | NeqGoal | LtGoal | LteGoal | GtGoal | GteGoal | SumGoal | CountGoal;
+export type Goal = AnyAtomGoal | NotGoal | AndGoal | OrGoal | ExistsGoal | LetGoal | AddGoal | SubGoal | MulGoal | DivGoal | DaysBetweenGoal | YearsBetweenGoal | MinGoal | MaxGoal | RoundToGoal | FloorToGoal | CeilToGoal | EqGoal | NeqGoal | LtGoal | LteGoal | GtGoal | GteGoal | SumGoal | CountGoal;
 /** A goal evaluated by recursively evaluating one or more child goals. */
 export type CompoundGoal = NotGoal | AndGoal | OrGoal | ExistsGoal | LetGoal;
 /** A goal evaluated directly by a primitive operator. */
-export type PrimitiveGoal = AddGoal | SubGoal | MulGoal | DivGoal | EqGoal | NeqGoal | LtGoal | LteGoal | GtGoal | GteGoal | SumGoal | CountGoal;
+export type PrimitiveGoal = AddGoal | SubGoal | MulGoal | DivGoal | DaysBetweenGoal | YearsBetweenGoal | MinGoal | MaxGoal | RoundToGoal | FloorToGoal | CeilToGoal | EqGoal | NeqGoal | LtGoal | LteGoal | GtGoal | GteGoal | SumGoal | CountGoal;

package/dist/core/types/judgment.d.ts

@@ -1,4 +1,4 @@
-import type { AnyAtomGoal, AtomGoal, CompoundGoal, Goal, GroundAtomGoal, PrimitiveGoal } from "./goal.js";
+import type { AnyAtomGoal, ArithmeticKind, AtomGoal, CompoundGoal, Goal, GroundAtomGoal, PrimitiveGoal } from "./goal.js";
 import type { AnyLiteral, Literal } from "./literal.js";
 import type { AnyRule, Rule } from "./rule.js";
 import type { Bindings } from "./common.js";
@@ -93,7 +93,7 @@ export type CountPrimitiveSupport = Readonly<{
     readonly results: Bindings;
 }>;
 /** Proof support for a primitive goal, narrowed to the support shape for the goal's kind. */
-export type PrimitiveSupportFor<GoalType extends PrimitiveGoal> = PrimitiveSupport | (GoalType["kind"] extends "add" | "sub" | "mul" | "div" ? ArithmeticPrimitiveSupport : GoalType["kind"] extends "eq" | "neq" | "lt" | "lte" | "gt" | "gte" ? ComparisonPrimitiveSupport : GoalType["kind"] extends "sum" ? SumPrimitiveSupport : GoalType["kind"] extends "count" ? CountPrimitiveSupport : never);
+export type PrimitiveSupportFor<GoalType extends PrimitiveGoal> = PrimitiveSupport | (GoalType["kind"] extends ArithmeticKind ? ArithmeticPrimitiveSupport : GoalType["kind"] extends "eq" | "neq" | "lt" | "lte" | "gt" | "gte" ? ComparisonPrimitiveSupport : GoalType["kind"] extends "sum" ? SumPrimitiveSupport : GoalType["kind"] extends "count" ? CountPrimitiveSupport : never);
 /** Sources of support allowed for a specific goal shape. */
 export type JudgmentSupportFor<GoalType extends Goal> = GoalType extends AtomGoal<infer Schema> ? EvidenceSupport<Schema> | ClosedWorldAbsenceSupport | RuleSupport<Schema> : GoalType extends AnyAtomGoal ? ErasedEvidenceSupport | ClosedWorldAbsenceSupport | ErasedRuleSupport : GoalType extends PrimitiveGoal ? PrimitiveSupportFor<GoalType> : GoalType extends CompoundGoal ? SubgoalsSupport : never;
 /** The evaluated goal and in-scope variable bindings shared by every judgment. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factbag",
-  "version": "0.0.0-alpha.2",
+  "version": "0.0.0-alpha.3",
   "keywords": [
     "logic",
     "rules-engine",