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

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # factbag
 
+## 0.0.0-alpha.4
+
+### Minor Changes
+
+- 2814aab: Allow enumerations to hold numbers or dates as well as strings, with one member
+  type per enumeration. Members must be unique; dates compare by instant and are
+  copied on construction. NaN and invalid dates are rejected. Enumeration membership
+  validation at assertion and query time is unchanged.
+- 1f5bb1b: Classify predicates whose fields are number or Date enumerations, alongside
+  string enumerations. Dates are sent to the model as ISO strings and retained as
+  `Date` values in evidence. Open-ended `String`, `Number`, and `Date` fields
+  remain unsupported.
+- 9ca1766: Reorganize classification and resolution to separate evidence workflows from model requests. The workflows own evidence admission and knowledge-base updates; the Jev implementation owns prompts, encoding, batching, and response validation.
+
+  **Breaking changes:** call the classifier with `classifier({ corpus, input, config })`. Classification and resolution jobs now expose only `execute(): Promise<void>`; read the resulting knowledge base from `run.kb`. Job metadata and assessment and resolution reports are removed. Replace `RequestConfig`, `ResolutionConfig`, and nested `AdmissionPolicy` settings with the shared, flat `Config`. Pass an SDK client directly instead of implementing the removed custom client interfaces.
+
+  Classification now executes one job per chunk across all permitted predicates. All responses for the chunk must validate before its evidence is written. Failed jobs can be retried without partial evidence, repeating the chunk's requests; successful repeats add fresh evidence.
+
+  Optionally filter candidates by passage relevance with `config: { routing: true }`. Each chunk first asks which predicates the passage may bear on. For predicates that make claims about supplied entities or values, it can also filter those symbols before combining them into complete candidate facts. `candidateProductCutoff` controls when this extra filtering runs. Filtering defaults to off: false negatives can suppress evidence, including denials, and the extra requests do not guarantee cost savings.
+
+  Expose `createConfig`, `Config`, and shared `DEFAULT_*` constants through `factbag/jev/config`. Normalize settings once and preserve a shared lazy client when a factory-created config is reused across workflows.
+
+  Export `fieldEquals` from `factbag/dsl` and use core equality in Jev: entities compare by constructor and ID, dates by instant. Resolution now groups contradictory evidence about separate instances of the same entity.
+
+  Encode candidate values when building requests, using the original entities and dates instead of construction-time JSON snapshots. Candidate domains remain fixed at run construction.
+
+## 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/README.md

@@ -79,7 +79,7 @@ class Person {
 
 const hasIncomeOver200k = predicate(
   "has_income_over_200k",
-  { person: Person, year: enumeration("2024", "2025") },
+  { person: Person, year: enumeration(2024, 2025) },
   {
     description:
       "The person's total individual annual income exceeded USD 200,000 in the " +
@@ -117,8 +117,8 @@ const kb = new KnowledgeBase();
 
 kb.rule(isQualifiedInvestor({ person })).if(
   and(
-    hasIncomeOver200k({ person, year: "2024" }),
-    hasIncomeOver200k({ person, year: "2025" }),
+    hasIncomeOver200k({ person, year: 2024 }),
+    hasIncomeOver200k({ person, year: 2025 }),
     expectsSameIncome({ person }),
   ),
 );
@@ -170,7 +170,7 @@ const incomeEvidence = guard(kb)
 ### 6. Ask Jev to assess the income evidence
 
 ```ts
-const run = classifier(corpus, incomeEvidence);
+const run = classifier({ corpus, input: incomeEvidence });
 
 for (const job of run) {
   await job.execute(); // Makes a live Jev request.

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

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

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/dsl/enumeration.d.ts

@@ -1,3 +1,7 @@
 import type { EnumType } from "../types/schema.js";
-/** Declare a nonempty finite string domain. Values must be unique. */
+/** Declare a nonempty finite domain of one member type. Values must be unique. */
 export declare function enumeration<const Value extends string>(first: Value, ...rest: readonly Value[]): EnumType<Value>;
+/** Declare a nonempty finite number domain. NaN and duplicate values are rejected. */
+export declare function enumeration<const Value extends number>(first: Value, ...rest: readonly Value[]): EnumType<Value>;
+/** Declare a nonempty finite date domain. Dates are copied and must have unique, valid instants. */
+export declare function enumeration(first: Date, ...rest: readonly Date[]): EnumType<Date>;

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

@@ -6,16 +6,16 @@
  */
 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";
 export type { Annotations, AnnotationValue } from "../types/annotations.js";
 export { variable } from "./variable.js";
 export type { Formula, Scalar, Term } from "./types.js";
-export { assertAtomLike, assertGroundAtom } from "../types/atom.js";
+export { assertAtomLike, assertGroundAtom, fieldEquals } from "../types/atom.js";
 export type { AnyAtom, Atom, GroundAtom, GroundFields, NonGroundAtom, PatternFields, } from "../types/atom.js";
 export type { Entity, EnumType, InferRuntime, PredicateSchema, RuntimeConstructor, RuntimeType, } from "../types/schema.js";
 export { Var } from "../types/variable.js";

package/dist/core/dsl/index.js

@@ -1,7 +1,8 @@
 import {
   assertAtomLike,
-  assertGroundAtom
-} from "../chunk-5J3WGMN2.js";
+  assertGroundAtom,
+  fieldEquals
+} from "../chunk-N2RRSOEN.js";
 import {
   Var
 } from "../chunk-UVOCOH2I.js";
@@ -68,8 +69,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);
@@ -121,10 +167,23 @@ function predicate(name, params, metadata) {
 
 // src/dsl/enumeration.ts
 function enumeration(first, ...rest) {
-  const values = [first, ...rest];
-  if (values.some((value) => typeof value !== "string") || new Set(values).size !== values.length) {
-    throw new Error("Enum values must be unique strings");
-  }
+  const kind = first instanceof Date ? "date" : typeof first;
+  const seen = /* @__PURE__ */ new Set();
+  const values = [first, ...rest].map((value) => {
+    const memberKind = value instanceof Date ? "date" : typeof value;
+    if (memberKind !== kind || kind !== "string" && kind !== "number" && kind !== "date") {
+      throw new Error("Enum values must all be strings, numbers, or dates of one type");
+    }
+    const key = value instanceof Date ? value.getTime() : value;
+    if (typeof key === "number" && Number.isNaN(key)) {
+      throw new Error("Enum values must not be NaN or invalid dates");
+    }
+    if (seen.has(key)) {
+      throw new Error("Enum values must be unique (dates compare by instant)");
+    }
+    seen.add(key);
+    return value instanceof Date ? new Date(key) : value;
+  });
   return Object.freeze({ kind: "enum", values: Object.freeze(values) });
 }
 
@@ -138,20 +197,30 @@ export {
   and,
   assertAtomLike,
   assertGroundAtom,
+  ceilTo,
   closedPredicate,
   count,
+  daysBetween,
   div,
   enumeration,
+  eq,
   exists,
+  fieldEquals,
+  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-N2RRSOEN.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";