@bjornpagen/bumbledb 0.9.0 → 0.11.0

package/dist/query/find.d.ts

@@ -3,11 +3,10 @@
  * vocabulary, mirroring the IR's aggregate roster exactly
  * (`bumbledb/crates/bumbledb/src/ir.rs` `AggOp`/`FindTerm`;
  * `docs/architecture/20-query-ir.md` § aggregation): `count` (nullary),
- * `countDistinct`, `sum`/`min`/`max` (over an orderable variable or the
- * measure), `argMax`/`argMin` (arg-restriction: carried value + orderable
- * key), and `pack` (the coalescing fold — RELATION-SHAPED, the result
- * position interval-typed). Aggregates fold VARIABLES by reference —
- * `r.sum(w)` — and are typed by the variable's own descriptor.
+ * `sum`/`min`/`max` (over an orderable variable or the measure), and
+ * `pack` (the coalescing fold — RELATION-SHAPED, the result position
+ * interval-typed). Aggregates fold VARIABLES by reference — `r.sum(w)` —
+ * and are typed by the variable's own descriptor.
  *
  * `select(strings)` is DEAD: the head is a `find` RECORD, whose KEYS name
  * the answer columns (`find({ total: r.count(), owner: h })`). The keys are
@@ -23,27 +22,23 @@ import type { SchemaClasses } from "#law.ts";
 import type { IntervalVarOk, NumericVarOk, OrderVarOk } from "#query/atom.ts";
 import type { AnyVar, Duration, MintSlotOf } from "#query/scope.ts";
 /** One aggregate operator name of the find vocabulary. */
-type AggOpName = "count" | "countDistinct" | "sum" | "min" | "max" | "argMax" | "argMin" | "pack";
+type AggOpName = "count" | "sum" | "min" | "max" | "pack";
 /**
- * One aggregate find VALUE: the op, the variable (or measure) it folds BY
- * REFERENCE, and — for the Arg forms — the orderable key variable. The
- * variable's own descriptor types the result.
+ * One aggregate find VALUE: the op and the variable (or measure) it folds
+ * BY REFERENCE. The variable's own descriptor types the result.
  */
-interface Agg<Op extends AggOpName, Over extends AnyVar | Duration | undefined, Key extends AnyVar | undefined = undefined> {
+interface Agg<Op extends AggOpName, Over extends AnyVar | Duration | undefined> {
     readonly agg: Op;
     readonly over: Over;
-    readonly key: Key;
 }
 /** Any aggregate find value. */
-type AnyAgg = Agg<AggOpName, AnyVar | Duration | undefined, AnyVar | undefined>;
+type AnyAgg = Agg<AggOpName, AnyVar | Duration | undefined>;
 /** One find entry: a projected variable, the measure, or an aggregate. */
 type FindEntry = AnyVar | Duration | AnyAgg;
 /** The `find` record: column name → find entry. Keys ARE the answer columns. */
 type FindShape = Readonly<Record<string, FindEntry>>;
 /** Nullary count: |the group's set of distinct full bindings|, `bigint`. */
 declare function count(): Agg<"count", undefined>;
-/** |the distinct values of the variable across the group|, `bigint`; legal over every type. */
-declare function countDistinct<const V extends AnyVar>(over: V): Agg<"countDistinct", V>;
 /**
  * Exact checked sum over a NUMERIC (u64/i64) variable — wide accumulator,
  * one finalize range check; overflow is the engine's typed runtime error —
@@ -55,22 +50,12 @@ declare function sum<const O extends AnyVar | Duration>(over: O): Agg<"sum", O>;
 declare function min<const O extends AnyVar | Duration>(over: O): Agg<"min", O>;
 /** Maximum over an orderable variable (u64/i64/bool — over bool, `Max` is the ANY quantifier; R3) or the measure. */
 declare function max<const O extends AnyVar | Duration>(over: O): Agg<"max", O>;
-/**
- * Arg-restriction toward the maximum of `key` (`ir::AggOp::ArgMax`): the
- * group's binding set is restricted to the bindings attaining the extreme
- * of the orderable key, and `value` is the carried payload — a tie yields
- * every attaining row. All Arg entries of one query share one key and one
- * direction; Arg and fold aggregates never mix (both the engine's rules).
- */
-declare function argMax<const V extends AnyVar, const K extends AnyVar>(value: V, key: K): Agg<"argMax", V, K>;
-/** Arg-restriction toward the minimum of `key`; rules as {@link argMax}. */
-declare function argMin<const V extends AnyVar, const K extends AnyVar>(value: V, key: K): Agg<"argMin", V, K>;
 /**
  * The coalescing fold (Snodgrass coalesce, `ir::AggOp::Pack`): per group,
  * the maximal disjoint half-open segments of the union of the group's
  * interval point sets — RELATION-SHAPED, one answer row per (group, maximal
  * segment), the result position carrying one interval of the input's element
- * type. At most one `pack` per find, never beside a fold or an Arg entry.
+ * type. At most one `pack` per find, never beside a fold entry.
  */
 declare function pack<const V extends AnyVar>(over: V): Agg<"pack", V>;
 /**
@@ -88,28 +73,26 @@ type FoldOverOk<O> = O extends AnyVar ? OrderVarOk<O> : O extends Duration<infer
 /**
  * One find entry's judgment (off the entry's own descriptor — no env, no
  * class map needed): a projected variable is ok, the measure and `pack`
- * demand interval-typed variables, folds and Arg keys demand orderable ones.
+ * demand interval-typed variables, folds demand orderable ones.
  */
-type FindEntryOk<E> = E extends AnyVar ? true : E extends Duration<infer V extends AnyVar> ? IntervalVarOk<V> : E extends Agg<"count", undefined> ? true : E extends Agg<"countDistinct", AnyVar> ? true : E extends Agg<"sum", infer O> ? SumOverOk<O> : E extends Agg<"min" | "max", infer O> ? FoldOverOk<O> : E extends Agg<"argMax" | "argMin", AnyVar, infer K extends AnyVar> ? OrderVarOk<K> extends true ? true : false : E extends Agg<"pack", infer V extends AnyVar> ? IntervalVarOk<V> : false;
+type FindEntryOk<E> = E extends AnyVar ? true : E extends Duration<infer V extends AnyVar> ? IntervalVarOk<V> : E extends Agg<"count", undefined> ? true : E extends Agg<"sum", infer O> ? SumOverOk<O> : E extends Agg<"min" | "max", infer O> ? FoldOverOk<O> : E extends Agg<"pack", infer V extends AnyVar> ? IntervalVarOk<V> : false;
 /** The validated find record (intersect with the inferred entries — errors land on the offending key). */
 type CheckFind<F extends FindShape> = {
     readonly [K in keyof F]: FindEntryOk<F[K]> extends true ? F[K] : never;
 };
 /**
  * The validated find record of a RECURSIVE rule: every entry must be a plain
- * variable (aggregates and the measure are unwritable in a recursive head —
- * the strata quarantine).
+ * variable (aggregates and the measure are unwritable in a rec head).
  */
 type CheckRecFind<F extends FindShape> = {
     readonly [K in keyof F]: F[K] extends AnyVar ? F[K] : never;
 };
 /**
  * One find entry's answer-column value type: a variable carries its field's
- * type, the measure/count/countDistinct are `bigint`, folds carry their
- * input's type (a measure fold is `bigint`), the Arg forms carry the
- * payload's type, `pack` its interval type.
+ * type, the measure/count are `bigint`, folds carry their input's type
+ * (a measure fold is `bigint`), `pack` its interval type.
  */
-type FindValue<E> = E extends AnyVar ? Infer<E["field"]> : E extends Duration<AnyVar> ? bigint : E extends Agg<"count", undefined> ? bigint : E extends Agg<"countDistinct", AnyVar> ? bigint : E extends Agg<"sum" | "min" | "max", infer O> ? O extends AnyVar ? Infer<O["field"]> : bigint : E extends Agg<"argMax" | "argMin", infer V extends AnyVar, AnyVar> ? Infer<V["field"]> : E extends Agg<"pack", infer V extends AnyVar> ? Infer<V["field"]> : never;
+type FindValue<E> = E extends AnyVar ? Infer<E["field"]> : E extends Duration<AnyVar> ? bigint : E extends Agg<"count", undefined> ? bigint : E extends Agg<"sum" | "min" | "max", infer O> ? O extends AnyVar ? Infer<O["field"]> : bigint : E extends Agg<"pack", infer V extends AnyVar> ? Infer<V["field"]> : never;
 /** The inferred answer-row object type of a find record — the keys ARE the columns. */
 type RowOfFind<F extends FindShape> = {
     readonly [K in keyof F]: FindValue<F[K]>;
@@ -117,11 +100,11 @@ type RowOfFind<F extends FindShape> = {
 /**
  * The head signature of a recursive rule's find record as classed mint
  * slots (descriptor + law-computed class), keyed by column name — the
- * signature an `idb` join pairs against (`F` is variable-only there).
+ * signature an interior join pairs against (`F` is variable-only there).
  */
 type HeadRecordOf<Classes extends SchemaClasses, F extends FindShape> = {
     readonly [K in keyof F]: F[K] extends AnyVar ? MintSlotOf<Classes, F[K]> : never;
 };
 export type { Agg, AggOpName, AnyAgg, CheckFind, CheckRecFind, FindEntry, FindEntryOk, FindShape, FindValue, HeadRecordOf, RowOfFind };
-export { argMax, argMin, count, countDistinct, max, min, pack, sum };
+export { count, max, min, pack, sum };
 //# sourceMappingURL=find.d.ts.map

package/dist/query/find.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../src/query/find.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../src/query/find.ts"],"names":[],"mappings":"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"}

package/dist/query/find.js

@@ -3,11 +3,10 @@
  * vocabulary, mirroring the IR's aggregate roster exactly
  * (`bumbledb/crates/bumbledb/src/ir.rs` `AggOp`/`FindTerm`;
  * `docs/architecture/20-query-ir.md` § aggregation): `count` (nullary),
- * `countDistinct`, `sum`/`min`/`max` (over an orderable variable or the
- * measure), `argMax`/`argMin` (arg-restriction: carried value + orderable
- * key), and `pack` (the coalescing fold — RELATION-SHAPED, the result
- * position interval-typed). Aggregates fold VARIABLES by reference —
- * `r.sum(w)` — and are typed by the variable's own descriptor.
+ * `sum`/`min`/`max` (over an orderable variable or the measure), and
+ * `pack` (the coalescing fold — RELATION-SHAPED, the result position
+ * interval-typed). Aggregates fold VARIABLES by reference — `r.sum(w)` —
+ * and are typed by the variable's own descriptor.
  *
  * `select(strings)` is DEAD: the head is a `find` RECORD, whose KEYS name
  * the answer columns (`find({ total: r.count(), owner: h })`). The keys are
@@ -19,16 +18,12 @@
  * aggregate — no minting or arithmetic term exists to spell (permanent law).
  */
 /** Builds one aggregate value. */
-function aggregate(op, over, key) {
-    return Object.freeze({ agg: op, over, key });
+function aggregate(op, over) {
+    return Object.freeze({ agg: op, over });
 }
 /** Nullary count: |the group's set of distinct full bindings|, `bigint`. */
 function count() {
-    return aggregate("count", undefined, undefined);
-}
-/** |the distinct values of the variable across the group|, `bigint`; legal over every type. */
-function countDistinct(over) {
-    return aggregate("countDistinct", over, undefined);
+    return aggregate("count", undefined);
 }
 /**
  * Exact checked sum over a NUMERIC (u64/i64) variable — wide accumulator,
@@ -37,39 +32,25 @@ function countDistinct(over) {
  * quantifier is not an addition (R3).
  */
 function sum(over) {
-    return aggregate("sum", over, undefined);
+    return aggregate("sum", over);
 }
 /** Minimum over an orderable variable (u64/i64/bool — over bool, `Min` is the ALL quantifier; R3) or the measure. */
 function min(over) {
-    return aggregate("min", over, undefined);
+    return aggregate("min", over);
 }
 /** Maximum over an orderable variable (u64/i64/bool — over bool, `Max` is the ANY quantifier; R3) or the measure. */
 function max(over) {
-    return aggregate("max", over, undefined);
-}
-/**
- * Arg-restriction toward the maximum of `key` (`ir::AggOp::ArgMax`): the
- * group's binding set is restricted to the bindings attaining the extreme
- * of the orderable key, and `value` is the carried payload — a tie yields
- * every attaining row. All Arg entries of one query share one key and one
- * direction; Arg and fold aggregates never mix (both the engine's rules).
- */
-function argMax(value, key) {
-    return aggregate("argMax", value, key);
-}
-/** Arg-restriction toward the minimum of `key`; rules as {@link argMax}. */
-function argMin(value, key) {
-    return aggregate("argMin", value, key);
+    return aggregate("max", over);
 }
 /**
  * The coalescing fold (Snodgrass coalesce, `ir::AggOp::Pack`): per group,
  * the maximal disjoint half-open segments of the union of the group's
  * interval point sets — RELATION-SHAPED, one answer row per (group, maximal
  * segment), the result position carrying one interval of the input's element
- * type. At most one `pack` per find, never beside a fold or an Arg entry.
+ * type. At most one `pack` per find, never beside a fold entry.
  */
 function pack(over) {
-    return aggregate("pack", over, undefined);
+    return aggregate("pack", over);
 }
-export { argMax, argMin, count, countDistinct, max, min, pack, sum };
+export { count, max, min, pack, sum };
 //# sourceMappingURL=find.js.map

package/dist/query/find.js.map

@@ -1 +1 @@
-{"version":3,"file":"find.js","sourceRoot":"","sources":["../../src/query/find.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAkCH,kCAAkC;AAClC,SAAS,SAAS,CACjB,EAAM,EACN,IAAU,EACV,GAAQ;IAER,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAA;AAC7C,CAAC;AAED,4EAA4E;AAC5E,SAAS,KAAK;IACb,OAAO,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;AAChD,CAAC;AAED,+FAA+F;AAC/F,SAAS,aAAa,CAAyB,IAAO;IACrD,OAAO,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AACnD,CAAC;AAED;;;;;GAKG;AACH,SAAS,GAAG,CAAoC,IAAO;IACtD,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AACzC,CAAC;AAED,qHAAqH;AACrH,SAAS,GAAG,CAAoC,IAAO;IACtD,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AACzC,CAAC;AAED,qHAAqH;AACrH,SAAS,GAAG,CAAoC,IAAO;IACtD,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AACzC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,MAAM,CAAiD,KAAQ,EAAE,GAAM;IAC/E,OAAO,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,CAAA;AACvC,CAAC;AAED,4EAA4E;AAC5E,SAAS,MAAM,CAAiD,KAAQ,EAAE,GAAM;IAC/E,OAAO,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,CAAA;AACvC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,IAAI,CAAyB,IAAO;IAC5C,OAAO,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AAC1C,CAAC;AAgHD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAA"}
+{"version":3,"file":"find.js","sourceRoot":"","sources":["../../src/query/find.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AA4BH,kCAAkC;AAClC,SAAS,SAAS,CACjB,EAAM,EACN,IAAU;IAEV,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;AACxC,CAAC;AAED,4EAA4E;AAC5E,SAAS,KAAK;IACb,OAAO,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;AACrC,CAAC;AAED;;;;;GAKG;AACH,SAAS,GAAG,CAAoC,IAAO;IACtD,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;AAC9B,CAAC;AAED,qHAAqH;AACrH,SAAS,GAAG,CAAoC,IAAO;IACtD,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;AAC9B,CAAC;AAED,qHAAqH;AACrH,SAAS,GAAG,CAAoC,IAAO;IACtD,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;AAC9B,CAAC;AAED;;;;;;GAMG;AACH,SAAS,IAAI,CAAyB,IAAO;IAC5C,OAAO,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;AAC/B,CAAC;AAoGD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAA"}

package/dist/query/lower.d.ts

@@ -18,11 +18,8 @@
  * `Params` inferred to be EXACTLY the params the rules use (params are typed
  * BY USE; a param no rule uses never registers). Variable IDENTITY is the
  * object reference: reusing one value across binding positions IS the join,
- * and a name-collision join is unrepresentable. Each binding position is
- * judged against the variable's MINT slot — and because {@link JoinOk} is an
- * equality, that alone makes every cross-binding join transitively
- * class-equal. Lowering is a pure function of the query value down to the
- * bridge's `ProgramIr` (`bumbledb/crates/bumbledb/src/ir.rs`): relations by
+ * lowering is a pure function of the query value down to the
+ * bridge's `QueryIr` (`bumbledb/crates/bumbledb/src/ir.rs`): relations by
  * declaration ordinal, variables by dense per-rule first-occurrence ids
  * (keyed on the object REFERENCE — the discipline is unchanged, only the map
  * key moved from name to reference), params by first-use order. Lowering is
@@ -30,18 +27,18 @@
  * two identically-written queries (fresh mints each) lower identically.
  * Construction validates negation safety and boundness (typed by the var's
  * label — object identity is invisible to the type tier, so these are
- * construction-time walls); everything else (strata, types, aggregate
+ * construction-time walls); everything else (types, aggregate
  * rosters, rule caps) is the ENGINE's judge, surfacing at prepare.
  */
 import type { AnyField } from "#fields.ts";
 import type { ClassRecordOf, SchemaClasses } from "#law.ts";
-import type { ProgramIr, TaggedValue } from "#native.ts";
-import type { AnyCond, BindParamsShape, CheckBindings, CheckCond, CmpKind, CondParamsShape, FindColumn, MatchFields, MatchOwner, MatchShape, RecData, RuleData } from "#query/atom.ts";
+import type { ParsedQuery, TaggedValue } from "#native.ts";
+import type { AnyCond, BindParamsShape, CheckBindings, CheckCond, CmpKind, CondParamsShape, FindColumn, InteriorData, MatchFields, MatchOwner, MatchShape, RecData, RecHandle, RecHead, RuleData } from "#query/atom.ts";
 import { allen, and, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts";
 import type { CheckFind, CheckRecFind, FindShape, HeadRecordOf, RowOfFind } from "#query/find.ts";
-import { argMax, argMin, count, countDistinct, max, min, pack, sum } from "#query/find.ts";
-import type { AnyVar, ClassedField, Flatten, InferredOf, JoinOk, MintSlotOf, ParamEntry, ParamsRecord } from "#query/scope.ts";
-import { inferred, makeDuration, makeMaskParam, makeParam, makeSetParam } from "#query/scope.ts";
+import { count, max, min, pack, sum } from "#query/find.ts";
+import type { AnyVar, ClassedField, Flatten, InferredOf, ParamEntry, ParamsRecord, ShapeOf } from "#query/scope.ts";
+import { inferred, makeDuration, makeParam, makeSetParam } from "#query/scope.ts";
 import type { AnySchema, Schema, SchemaRelations } from "#schema.ts";
 /**
  * The matchable members of a schema's record — ordinary relations AND
@@ -58,15 +55,15 @@ type RowOf<T> = InferredOf<T> extends {
     readonly row: infer R;
 } ? R : never;
 /**
- * A recursive predicate's HEAD signature as classed slots, keyed by column
- * name — carried on the rec reference so an `idb` join can be judged against
- * it; `undefined` on values that carry no head.
+ * A derived table's HEAD signature as classed slots, keyed by column
+ * name; `undefined` on values that carry no head.
  */
 type HeadShape = Readonly<Record<string, ClassedField>> | undefined;
 /**
  * One finished rule as a plain value: the runtime data plus the inferred
- * row/params carrier (and, for a RECURSIVE rule, the head record of classed
- * slots `idb` pairs against). `.rule(...)` consumes it.
+ * row/params carrier (and, for an interior or recursive rule, the head
+ * record of classed slots an `.interior(name)` join pairs against).
+ * `.rule(...)` consumes it.
  */
 interface RuleValue<Row, P extends ParamsRecord, Head extends HeadShape = undefined> {
     readonly rule: RuleData;
@@ -82,38 +79,25 @@ type AnyRuleValue = RuleValue<unknown, ParamsRecord, HeadShape>;
 type HeadOf<T> = InferredOf<T> extends {
     readonly head: infer H extends Readonly<Record<string, ClassedField>>;
 } ? H : undefined;
+/** One `.interior(name)` position's judgment: a variable. */
+type InteriorBindingOk<V> = V extends AnyVar ? true : false;
 /**
- * A recursive predicate REFERENCE — the shape `idb()` targets carry: the
- * name (type-level identity), the runtime data (value identity), the params
- * its rules have used, and the head signature its FIRST rule sealed.
+ * The validated `.interior(name)` bindings record: every entry must be a
+ * variable. Arity and class against the named table's head are
+ * construction-time (the name is a string, so the head is not a type-level
+ * fact).
  */
-interface RecRef<Name extends string, P extends ParamsRecord, Head extends HeadShape = HeadShape> {
-    readonly name: Name;
-    readonly data: RecData;
-    readonly [inferred]?: {
-        readonly params: P;
-        readonly head: Head;
-    };
-}
-/** One `idb` position's judgment: a variable class-equal to the head slot when the head is carried. */
-type IdbBindingOk<Classes extends SchemaClasses, HeadSlot, V> = V extends AnyVar ? HeadSlot extends ClassedField ? JoinOk<HeadSlot, MintSlotOf<Classes, V>> extends true ? true : false : true : false;
-/**
- * The validated `idb` bindings record: when the target carries its head
- * (a threaded rec handle), the record's key set must EXACTLY equal the
- * head's (a missing or extra key maps every property to `never`) and each
- * variable must be class-equal to its head slot — the same wall `JoinOk`
- * holds for EDB atoms. An unthreaded handle carries no head; every entry
- * must still be a variable, arity/class judged at construction and prepare.
- */
-type CheckIdbBindings<Classes extends SchemaClasses, Head, B> = Head extends Readonly<Record<string, ClassedField>> ? [keyof B] extends [keyof Head] ? [keyof Head] extends [keyof B] ? {
-    readonly [K in keyof B]: K extends keyof Head ? IdbBindingOk<Classes, Head[K], B[K]> extends true ? B[K] : never : never;
-} : {
-    readonly [K in keyof B]: never;
-} : {
-    readonly [K in keyof B]: never;
-} : {
-    readonly [K in keyof B]: B[K] extends AnyVar ? B[K] : never;
+type CheckInteriorBindings<B> = {
+    readonly [K in keyof B]: InteriorBindingOk<B[K]> extends true ? B[K] : never;
 };
+/** One interior-rule builder function. */
+type InteriorBuild<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> = (r: InteriorRuleScope<Rels, Classes>) => AnyRuleValue;
+/** One rec-arm builder function. */
+type RecBuild<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> = (r: RecRuleScope<Rels, Classes>) => AnyRuleValue;
+/** A build function's rule value. */
+type BuiltRule<F> = F extends (r: never) => infer RV ? RV : never;
+/** The intersected params record of a tuple of rule builds. */
+type BuildsParams<Builds extends readonly ((r: never) => AnyRuleValue)[]> = ShapeOf<ParamsOf<BuiltRule<Builds[number]>>>;
 /**
  * The term/predicate/aggregate constructor vocabulary every rule builder
  * carries — pure value builders. Variables are minted by the free {@link v},
@@ -124,8 +108,6 @@ interface TermOps {
     readonly param: typeof makeParam;
     /** Names one ∈-set parameter (the IR's `ParamSet`): bound to a readonly array at execution. */
     readonly inSet: typeof makeSetParam;
-    /** Names one Allen-mask parameter (`MaskTerm::Param`): a bind-time 13-bit mask number. */
-    readonly maskParam: typeof makeMaskParam;
     /** The measure of an interval-typed variable: `|[s, e)| = e − s`, u64. */
     readonly duration: typeof makeDuration;
     readonly eq: typeof eq;
@@ -140,18 +122,22 @@ interface TermOps {
     readonly or: typeof or;
     readonly not: typeof not;
     readonly count: typeof count;
-    readonly countDistinct: typeof countDistinct;
     readonly sum: typeof sum;
     readonly min: typeof min;
     readonly max: typeof max;
-    readonly argMax: typeof argMax;
-    readonly argMin: typeof argMin;
     readonly pack: typeof pack;
 }
 /** The rule builder a `query(S).rule(...)` callback receives (`Classes` — the join judge's authority). */
 interface QueryRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> extends TermOps {
     /** The first EDB atom of the rule: fields bind variables, params, ∈-sets, or bare literals; absence is the wildcard. */
     match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): QueryRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>;
+    /**
+     * A rule may START with a finished table: an interior atom is a positive
+     * occurrence exactly as the engine represents it, so its variables ground
+     * — the identity projection `(c) | reach(c);` is spellable with no
+     * re-grounding join over a domain relation.
+     */
+    interior<const B extends Readonly<Record<string, AnyVar>>>(name: string, bindings: B & CheckInteriorBindings<B>): QueryRuleChain<Rels, Record<never, never>, Classes>;
 }
 /** The chain of a plain query rule: more atoms, residual predicates, then the head. */
 interface QueryRuleChain<Rels extends SchemaRelations, P extends ParamsRecord, Classes extends SchemaClasses = SchemaClasses> {
@@ -159,61 +145,51 @@ interface QueryRuleChain<Rels extends SchemaRelations, P extends ParamsRecord, C
     match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): QueryRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>;
     /** One residual predicate: a comparison, an `and`/`or` tree, or a negated atom (`r.not`). */
     where<const C extends AnyCond>(cond: CheckCond<Classes, C> & C): QueryRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>;
+    /** One interior atom over a finished table (an earlier interior, or the rec). */
+    interior<const B extends Readonly<Record<string, AnyVar>>>(name: string, bindings: B & CheckInteriorBindings<B>): QueryRuleChain<Rels, P, Classes>;
     /** The head projection: a `find` RECORD whose keys name the answer columns. */
     find<const F extends FindShape>(entries: F & CheckFind<F>): RuleValue<RowOfFind<F>, P>;
 }
-/** The rule builder an OUTPUT rule of a `program()` receives: a query rule plus finished-stratum `idb` atoms. */
-interface OutputRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> extends TermOps {
-    match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): OutputRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>;
-    /**
-     * A rule may START with the finished stratum: an idb atom is a positive
-     * occurrence exactly as the engine represents it, so its variables ground
-     * — the identity projection `(c) | reach(c);` is spellable with no
-     * re-grounding join over a domain relation.
-     */
-    idb<Target extends RecRef<string, ParamsRecord>, const B extends Readonly<Record<string, AnyVar>>>(target: Target, bindings: B & CheckIdbBindings<Classes, HeadOf<Target>, B>): OutputRuleChain<Rels, ParamsOf<Target>, Classes>;
+/** The rule builder an `interior("mid", ...)` callback receives. */
+interface InteriorRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> extends TermOps {
+    match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): InteriorRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>;
+    interior<const B extends Readonly<Record<string, AnyVar>>>(name: string, bindings: B & CheckInteriorBindings<B>): InteriorRuleChain<Rels, Record<never, never>, Classes>;
 }
-/** The chain of an output rule: atoms, predicates, `idb` joins over the program's recs, then the head. */
-interface OutputRuleChain<Rels extends SchemaRelations, P extends ParamsRecord, Classes extends SchemaClasses = SchemaClasses> {
-    match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): OutputRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>;
-    where<const C extends AnyCond>(cond: CheckCond<Classes, C> & C): OutputRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>;
-    /**
-     * One `idb` atom over a FINISHED stratum (any rec of this program): a
-     * NAMED join against the rec's head — the bindings record's keys are the
-     * head columns, each bound to a variable positively bound by a relation
-     * atom of the rule. Threading the rec value the last `.rule(...)` returned
-     * carries its params into `Params` AND its head signature, so the join is
-     * key-exact and class-checked against the head at compile time.
-     */
-    idb<Target extends RecRef<string, ParamsRecord>, const B extends Readonly<Record<string, AnyVar>>>(target: Target, bindings: B & CheckIdbBindings<Classes, HeadOf<Target>, B>): OutputRuleChain<Rels, Flatten<P & ParamsOf<Target>>, Classes>;
-    find<const F extends FindShape>(entries: F & CheckFind<F>): RuleValue<RowOfFind<F>, P>;
+/** The chain of an interior rule: bound-variable heads only. */
+interface InteriorRuleChain<Rels extends SchemaRelations, P extends ParamsRecord, Classes extends SchemaClasses = SchemaClasses> {
+    match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): InteriorRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>;
+    where<const C extends AnyCond>(cond: CheckCond<Classes, C> & C): InteriorRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>;
+    interior<const B extends Readonly<Record<string, AnyVar>>>(name: string, bindings: B & CheckInteriorBindings<B>): InteriorRuleChain<Rels, P, Classes>;
+    find<const F extends FindShape>(entries: F & CheckRecFind<F>): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>;
 }
-/** The rule builder a RECURSIVE rule (`rec.rule(...)`) receives. */
-interface RecRuleScope<Rels extends SchemaRelations, Self extends string, Classes extends SchemaClasses = SchemaClasses> extends TermOps {
-    match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): RecRuleChain<Rels, Self, BindParamsShape<MatchFields<R>, B>, Classes>;
+/** The rule builder a `recursive("reach", { base, rec })` arm receives. */
+interface RecRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> extends TermOps {
+    match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): RecRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>;
+    interior<const B extends Readonly<Record<string, AnyVar>>>(name: string, bindings: B & CheckInteriorBindings<B>): RecRuleChain<Rels, Record<never, never>, Classes>;
 }
 /**
- * The chain of a recursive rule. Its `idb` accepts ONLY the rec itself (the
- * self-recursion cut) and its `find` takes bound variables only — aggregates
- * and the measure are unrepresentable in a recursive head.
+ * The chain of a recursive arm. `.interior("reach", …)` is the self-atom
+ * on rec arms (and a prior interior on either list). `find` takes bound
+ * variables only — aggregates and the measure are unrepresentable in a
+ * recursive head.
  */
-interface RecRuleChain<Rels extends SchemaRelations, Self extends string, P extends ParamsRecord, Classes extends SchemaClasses = SchemaClasses> {
-    match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): RecRuleChain<Rels, Self, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>;
-    where<const C extends AnyCond>(cond: CheckCond<Classes, C> & C): RecRuleChain<Rels, Self, Flatten<P & CondParamsShape<C>>, Classes>;
-    /** The self-recursive atom: `idb(self, { headKey: boundVar })` — only this rec's own reference is accepted. */
-    idb<Target extends RecRef<Self, ParamsRecord>, const B extends Readonly<Record<string, AnyVar>>>(target: Target, bindings: B & CheckIdbBindings<Classes, HeadOf<Target>, B>): RecRuleChain<Rels, Self, P, Classes>;
-    /** The recursive head: a `find` record of bound variables only; the value carries the head's classed slots for `idb` pairing. */
+interface RecRuleChain<Rels extends SchemaRelations, P extends ParamsRecord, Classes extends SchemaClasses = SchemaClasses> {
+    match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>): RecRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>;
+    where<const C extends AnyCond>(cond: CheckCond<Classes, C> & C): RecRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>;
+    interior<const B extends Readonly<Record<string, AnyVar>>>(name: string, bindings: B & CheckInteriorBindings<B>): RecRuleChain<Rels, P, Classes>;
     find<const F extends FindShape>(entries: F & CheckRecFind<F>): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>;
 }
 /** A query's runtime description — everything lowering, the wire marshal, and answer decode read. */
 interface QueryData {
-    /** The program's recursive predicates in declaration order (empty for a plain query); `PredId` = index. */
-    readonly recs: readonly RecData[];
-    /** The output rules in written order (multiple rules = set union). */
+    /** Named interiors in declaration order (DAG). */
+    readonly interiors: readonly InteriorData[];
+    /** The optional linear rec. */
+    readonly rec: RecData | null;
+    /** The main rules in written order (multiple rules = set union). */
     readonly rules: readonly RuleData[];
     /** The head columns (every rule derives the same head; written order = answer column order). */
     readonly finds: readonly FindColumn[];
-    /** The registered params in first-use order across the program walk (= dense `ParamId`s). */
+    /** The registered params in first-use order across the query walk (= dense `ParamId`s). */
     readonly params: readonly ParamEntry[];
 }
 /**
@@ -226,6 +202,10 @@ interface Query<Rels extends SchemaRelations, Row, Params extends ParamsRecord,
     readonly data: QueryData;
     /** One more rule — the query's answers are the SET UNION of its rules' answers; every rule derives the same head. */
     rule<RV extends AnyRuleValue>(build: (r: QueryRuleScope<Rels, Classes>) => RV): Query<Rels, Row | RowOf<RV>, Flatten<Params & ParamsOf<RV>>, Classes>;
+    /** Construction error: interiors precede main rules. Uncallable after `.rule()`. */
+    interior(name: string, ...builds: never[]): never;
+    /** Construction error: recursive precedes main rules. Uncallable after `.rule()`. */
+    recursive(name: string, arms: never): never;
     readonly [inferred]?: {
         readonly row: Row;
         readonly params: Params;
@@ -240,10 +220,23 @@ interface AnyQuery {
 type QueryRow<Q extends AnyQuery> = RowOf<Q>;
 /** Extracts a query value's inferred execute-params type. */
 type QueryParams<Q extends AnyQuery> = ParamsOf<Q>;
-/** The entry value of `query(S)`: the first `.rule` mints the query. */
-interface QueryStart<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> {
-    rule<RV extends AnyRuleValue>(build: (r: QueryRuleScope<Rels, Classes>) => RV): Query<Rels, RowOf<RV>, ParamsOf<RV>, Classes>;
-}
+/**
+ * The entry value of `query(S)`: interiors, then optional recursive, then
+ * the first `.rule` mints the query. `interior` / `recursive` exist only
+ * while `Rec` is `null`; `.recursive()` moves the type parameter.
+ */
+type QueryStart<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses, P extends ParamsRecord = Record<never, never>, Rec extends RecData | null = null> = {
+    rule<RV extends AnyRuleValue>(build: (r: QueryRuleScope<Rels, Classes>) => RV): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes>;
+} & (Rec extends null ? {
+    interior<const Builds extends readonly InteriorBuild<Rels, Classes>[]>(name: string, ...builds: Builds): QueryStart<Rels, Classes, Flatten<P & BuildsParams<Builds>>, null>;
+    recursive<const Base extends readonly RecBuild<Rels, Classes>[], const Step extends readonly RecBuild<Rels, Classes>[]>(name: string, arms: {
+        readonly base: Base;
+        readonly rec: Step;
+    }): QueryStart<Rels, Classes, Flatten<P & BuildsParams<Base> & BuildsParams<Step>>, RecData>;
+} : {
+    interior: never;
+    recursive: never;
+});
 /**
  * The one runtime chain every context shares — non-generic on purpose. The
  * typed chain interfaces apply at the scope factories' boundaries.
@@ -251,45 +244,43 @@ interface QueryStart<Rels extends SchemaRelations, Classes extends SchemaClasses
 interface RawChain {
     match(relation: MatchOwner, bindings: Readonly<Record<string, unknown>>): RawChain;
     where(cond: AnyCond): RawChain;
-    idb(target: RecRef<string, ParamsRecord>, bindings: Readonly<Record<string, unknown>>): RawChain;
+    interior(name: string, bindings: Readonly<Record<string, unknown>>): RawChain;
     find(entries: Readonly<Record<string, unknown>>): RuleValue<never, never>;
 }
 /** The runtime rule-builder shape beneath every typed scope. */
 interface RawScope extends TermOps {
     match(relation: MatchOwner, bindings: Readonly<Record<string, unknown>>): RawChain;
-    idb(target: RecRef<string, ParamsRecord>, bindings: Readonly<Record<string, unknown>>): RawChain;
+    interior(name: string, bindings: Readonly<Record<string, unknown>>): RawChain;
+}
+/** The declared derived tables a chain may name. */
+interface DerivedEnv {
+    readonly interiors: readonly InteriorData[];
+    readonly rec: RecHandle | RecHead | RecData | null;
 }
 /** Which rule family a chain builds — plus the schema's runtime class map and theory value (the join judge's authority). */
 type ChainContext = {
     readonly classes: SchemaClasses;
     readonly theory: AnySchema;
-} & ({
+} & DerivedEnv & ({
     readonly kind: "query";
 } | {
-    readonly kind: "rec";
-    readonly self: RecData;
+    readonly kind: "interior";
+    readonly self: string;
 } | {
-    readonly kind: "output";
-    readonly program: ProgramState;
+    readonly kind: "rec-base";
+    readonly self: RecHandle;
+} | {
+    readonly kind: "rec-arm";
+    readonly self: RecHead;
 });
 /** Builds one runtime rule-builder over a context. */
 declare function makeRawScope(context: ChainContext): RawScope;
-/** Builds one output-rule builder over a program's recs. */
-declare function makeOutputRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses>(program: ProgramState): OutputRuleScope<Rels, Classes>;
-/** One program's build-time registry: its recs in declaration order, the theory value, and its class map. */
-interface ProgramState {
-    readonly recs: RecData[];
-    readonly classes: SchemaClasses;
-    readonly theory: AnySchema;
-    sealed: boolean;
-}
-/** Assembles one typed query value (rules already completed). */
-declare function makeQuery<Rels extends SchemaRelations, Row, P extends ParamsRecord, Classes extends SchemaClasses>(theory: Schema<Rels, Classes>, recs: readonly RecData[], rules: readonly RuleData[]): Query<Rels, Row, P, Classes>;
 /**
- * Opens a query over a schema: `query(S).rule(r => ...)`. Each `.rule` adds
- * one conjunctive rule; multiple rules are the set union. The schema's
- * law-computed class map and theory value ride into every rule builder — the
- * join walls compare against the mint slots off it.
+ * Opens a query over a schema: `query(S).rule(r => ...)`, optionally with
+ * `interior` / `recursive` first. Each `.rule` adds one conjunctive rule;
+ * multiple rules are the set union. The schema's law-computed class map and
+ * theory value ride into every rule builder — the join walls compare
+ * against the mint slots off it.
  */
 declare function query<Rels extends SchemaRelations, Classes extends SchemaClasses>(theory: Schema<Rels, Classes>): QueryStart<Rels, Classes>;
 /**
@@ -308,11 +299,11 @@ declare function taggedLiteral(context: string, field: AnyField, value: unknown)
  */
 declare function taggedCmpLiteral(context: string, sibling: AnyField | "measure", value: unknown, op: CmpKind | "binding"): TaggedValue;
 /**
- * Lowers a query value to the bridge's `ProgramIr` — pure and stable: the
- * recs in declaration order (`PredId` = index), the output predicate
- * appended last. Every registered param must carry a field anchor by now.
+ * Lowers a query value to the bridge's `QueryIr` — pure and stable: interiors
+ * in declaration order, optional rec, then main. Every registered param must
+ * carry a field anchor by now.
  */
-declare function lowerQuery(q: AnyQuery): ProgramIr;
-export type { AnyQuery, AnyRuleValue, HeadOf, HeadShape, OutputRuleChain, OutputRuleScope, ParamsOf, ProgramState, Query, QueryData, QueryParams, QueryRelation, QueryRow, QueryRuleChain, QueryRuleScope, QueryStart, RawChain, RawScope, RecRef, RecRuleChain, RecRuleScope, RowOf, RuleValue, TermOps };
-export { lowerQuery, makeOutputRuleScope, makeQuery, makeRawScope, query, taggedCmpLiteral, taggedLiteral };
+declare function lowerQuery(q: AnyQuery): ParsedQuery;
+export type { AnyQuery, AnyRuleValue, HeadOf, HeadShape, InteriorRuleChain, InteriorRuleScope, ParamsOf, Query, QueryData, QueryParams, QueryRelation, QueryRow, QueryRuleChain, QueryRuleScope, QueryStart, RawChain, RawScope, RecRuleChain, RecRuleScope, RowOf, RuleValue, TermOps };
+export { lowerQuery, makeRawScope, query, taggedCmpLiteral, taggedLiteral };
 //# sourceMappingURL=lower.d.ts.map