@bjornpagen/bumbledb 0.10.0 → 0.11.0

package/dist/query/lower.js

@@ -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,20 +27,20 @@
  * 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 * as errors from "@superbuilders/errors";
 import { sealedFieldsOf } from "#closed.ts";
 import { assertDeclarationOrderKey, isIntervalValue, literalShapeError, rosterOf } from "#fields.ts";
 import { allen, and, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts";
-import { argMax, argMin, count, countDistinct, max, min, pack, sum } from "#query/find.ts";
-import { fieldJoins, inferred, isTerm, makeDuration, makeMaskParam, makeParam, makeSetParam, renderFieldKind, term } from "#query/scope.ts";
+import { count, max, min, pack, sum } from "#query/find.ts";
+import { parseQueryIr } from "#query/parse-ir.ts";
+import { fieldJoins, inferred, isTerm, makeDuration, makeParam, makeSetParam, renderFieldKind, term } from "#query/scope.ts";
 /** The frozen constructor vocabulary every rule builder spreads. */
 const termOps = Object.freeze({
     param: makeParam,
     inSet: makeSetParam,
-    maskParam: makeMaskParam,
     duration: makeDuration,
     eq,
     ne,
@@ -57,12 +54,9 @@ const termOps = Object.freeze({
     or,
     not,
     count,
-    countDistinct,
     sum,
     min,
     max,
-    argMax,
-    argMin,
     pack
 });
 /** The empty rule state. */
@@ -177,8 +171,6 @@ function resolveBindings(context, label, relation, bindings) {
                     }));
                     break;
                 }
-                case "maskParam":
-                    throw errors.new(`${label}.${fieldName}: an Allen-mask param is not a field-typed value — masks live in allen() conditions only`);
                 case "duration":
                     throw errors.new(`${label}.${fieldName}: the measure is not a field-typed value — it lives in comparisons and find entries`);
             }
@@ -215,7 +207,7 @@ function advanceMatch(context, state, relation, bindings) {
     });
 }
 /** Resolves one comparison side to its runtime term (variables and the measure ride by reference). */
-function cmpTermDataOf(op, value) {
+function cmpTermDataOf(value) {
     if (isTerm(value)) {
         switch (value[term]) {
             case "var":
@@ -226,8 +218,6 @@ function cmpTermDataOf(op, value) {
                 return Object.freeze({ kind: "setParam", name: value.name });
             case "duration":
                 return Object.freeze({ kind: "measure", ref: value.over });
-            case "maskParam":
-                throw errors.new(`${op}: an Allen-mask param is not a comparison term — masks live in allen()'s mask position`);
         }
     }
     return Object.freeze({ kind: "literal", value });
@@ -262,31 +252,23 @@ function sideUses(op, side, sibling, uses) {
 /** Lowers one condition VALUE to its runtime data, recording param uses. */
 function condDataOf(cond, uses) {
     if (cond.cond === "cmp") {
-        const lhs = cmpTermDataOf(cond.op, cond.lhs);
-        const rhs = cmpTermDataOf(cond.op, cond.rhs);
+        const lhs = cmpTermDataOf(cond.lhs);
+        const rhs = cmpTermDataOf(cond.rhs);
         sideUses(cond.op, lhs, rhs, uses);
         sideUses(cond.op, rhs, lhs, uses);
-        let mask;
         if (cond.op === "allen") {
             const maskValue = cond.mask;
-            if (typeof maskValue === "number") {
-                mask = Object.freeze({ kind: "literal", mask: maskValue });
-            }
-            else if (isTerm(maskValue) && maskValue[term] === "maskParam") {
-                mask = Object.freeze({ kind: "param", name: maskValue.name });
-                uses.push(Object.freeze({
-                    name: maskValue.name,
-                    shape: "mask",
-                    anchor: undefined,
-                    op: "allen",
-                    members: undefined
-                }));
-            }
-            else {
-                throw errors.new("allen: the mask position takes a 13-bit mask number or a maskParam");
+            if (typeof maskValue !== "number") {
+                throw errors.new("allen: the mask position takes a 13-bit mask number built from the ALLEN constants");
             }
+            return Object.freeze({
+                kind: "cmp",
+                op: { kind: "allen", mask: maskValue },
+                lhs,
+                rhs
+            });
         }
-        return Object.freeze({ kind: "cmp", op: cond.op, mask, lhs, rhs });
+        return Object.freeze({ kind: "cmp", op: { kind: cond.op }, lhs, rhs });
     }
     if (cond.cond === "tree") {
         const children = cond.children.map(function lowerChild(child) {
@@ -301,11 +283,11 @@ function advanceWhere(context, state, cond) {
     if (typeof cond !== "object" || cond === null || !("cond" in cond)) {
         throw errors.new("where() takes a comparison, an and()/or() tree, or a negated atom");
     }
-    if (cond.cond === "notIdb") {
+    if (cond.cond === "notInterior") {
         const bindings = Object.fromEntries(Object.entries(cond.bindings ?? {}).filter(function defined([, value]) {
             return value !== undefined;
         }));
-        return notIdbAdvance(context, state, cond.target, bindings);
+        return notInteriorAdvance(context, state, cond.name, bindings);
     }
     if (cond.cond === "not") {
         const relation = cond.relation;
@@ -328,36 +310,33 @@ function advanceWhere(context, state, cond) {
     });
 }
 /**
- * Extends a rule state with one `idb` atom (a named record over head keys;
- * vars validated at completion). A POSITIVE idb atom is a positive
- * occurrence exactly as the engine represents it (`check_atoms` walks Idb
+ * Extends a rule state with one interior atom (a named record over head keys;
+ * vars validated at completion). A POSITIVE interior atom is a positive
+ * occurrence exactly as the engine represents it (`check_atoms` walks Interior
  * and Edb in one loop), so its variables GROUND: they enter the rule's
  * boundness set, may ride the head, and satisfy negation safety — the
- * idb-only identity projection of a finished stratum is spellable with no
+ * interior-only identity projection of a finished table is spellable with no
  * re-grounding join. A NEGATED one binds nothing, only rejects.
  */
-function advanceIdb(state, rec, bindings, negated) {
+function advanceInterior(state, target, bindings, kind) {
     const resolved = [];
     for (const [key, value] of Object.entries(bindings)) {
         if (value === undefined) {
             continue;
         }
         if (!isTerm(value) || value[term] !== "var") {
-            throw errors.new(`idb ${rec.name}: position ${key} takes a variable — bind literals and params through where()/match()`);
+            throw errors.new(`interior ${target.name}: position ${key} takes a variable — bind literals and params through where()/match()`);
         }
         resolved.push(Object.freeze({ key, ref: value }));
     }
     const bound = new Set(state.bound);
-    if (!negated) {
+    if (kind === "interior") {
         for (const binding of resolved) {
             bound.add(binding.ref);
         }
     }
     return Object.freeze({
-        items: Object.freeze([
-            ...state.items,
-            Object.freeze({ kind: "idb", rec, bindings: Object.freeze(resolved), negated })
-        ]),
+        items: Object.freeze([...state.items, Object.freeze({ kind, target, bindings: Object.freeze(resolved) })]),
         bound,
         paramUses: state.paramUses
     });
@@ -379,8 +358,6 @@ function aggDataOf(name, entry) {
     switch (entry.agg) {
         case "count":
             return Object.freeze({ op: "count" });
-        case "countDistinct":
-            return Object.freeze({ op: "countDistinct", over: asVarTerm(`find ${name} (countDistinct)`, over) });
         case "sum":
         case "min":
         case "max": {
@@ -392,14 +369,6 @@ function aggDataOf(name, entry) {
             }
             throw errors.new(`find ${name} (${entry.agg}): takes a variable or r.duration(v)`);
         }
-        case "argMax":
-        case "argMin":
-            return Object.freeze({
-                op: "arg",
-                direction: entry.agg,
-                over: asVarTerm(`find ${name} (${entry.agg})`, over),
-                key: asVarTerm(`find ${name} (${entry.agg} key)`, entry.key)
-            });
         case "pack":
             return Object.freeze({ op: "pack", over: asVarTerm(`find ${name} (pack)`, over) });
         default:
@@ -473,17 +442,14 @@ function assertNotClosed(where, position, ref) {
 }
 /**
  * The classed mint slot one answer column's VALUES flow from: a projected
- * variable's mint slot, or an Arg-carried payload's. Counts, folds, `pack`
- * and the measure derive numbers/intervals, so they resolve no slot.
+ * variable's mint slot. Counts, folds, `pack` and the measure derive
+ * numbers/intervals, so they resolve no slot.
  */
 function findColumnSlotOf(context, column) {
     const entry = column.entry;
     if (entry.kind === "var") {
         return mintSlotOf(context, entry.over);
     }
-    if (entry.kind === "aggregate" && entry.agg.op === "arg") {
-        return mintSlotOf(context, entry.agg.over);
-    }
     return undefined;
 }
 /** Validates one find column's variable references (boundness + the orderable/interval walls, off the var's own field). */
@@ -503,9 +469,6 @@ function validateColumn(context, bound, column) {
     switch (agg.op) {
         case "count":
             return;
-        case "countDistinct":
-            assertBound(where, bound, agg.over);
-            return;
         case "fold": {
             if ("duration" in agg.over) {
                 assertBound(where, bound, agg.over.duration);
@@ -516,12 +479,6 @@ function validateColumn(context, bound, column) {
             assertNotClosed(where, `the ${agg.fold} input`, agg.over);
             return;
         }
-        case "arg": {
-            assertBound(where, bound, agg.over);
-            assertBound(where, bound, agg.key);
-            assertNotClosed(where, `the ${agg.direction} key`, agg.key);
-            return;
-        }
         case "pack":
             assertBound(where, bound, agg.over);
             assertInterval(where, agg.over);
@@ -540,8 +497,8 @@ function validateCond(context, bound, cond) {
             if (side.kind === "var") {
                 assertBound(label, bound, side.ref);
                 const roster = rosterOf(side.ref.field);
-                if (isOrderOp(cond.op) && roster !== undefined) {
-                    throw closedOrderError(label, `the ${cond.op} side ${side.ref.label}`, roster.name);
+                if (isOrderOp(cond.op.kind) && roster !== undefined) {
+                    throw closedOrderError(label, `the ${cond.op.kind} side ${side.ref.label}`, roster.name);
                 }
             }
             if (side.kind === "measure") {
@@ -549,13 +506,13 @@ function validateCond(context, bound, cond) {
                 assertInterval(label, side.ref);
             }
         }
-        if ((cond.op === "eq" || cond.op === "ne") && cond.lhs.kind === "var" && cond.rhs.kind === "var") {
+        if ((cond.op.kind === "eq" || cond.op.kind === "ne") && cond.lhs.kind === "var" && cond.rhs.kind === "var") {
             assertBound(label, bound, cond.lhs.ref);
             assertBound(label, bound, cond.rhs.ref);
             const lhs = mintSlotOf(context, cond.lhs.ref);
             const rhs = mintSlotOf(context, cond.rhs.ref);
             if (!fieldJoins(lhs, rhs)) {
-                throw errors.new(`${label}: ${cond.op}(${cond.lhs.ref.label}, ${cond.rhs.ref.label}) unifies domain-unequal fields — ${cond.lhs.ref.label} bound at ${renderFieldKind(lhs)}, ${cond.rhs.ref.label} at ${renderFieldKind(rhs)} (a var joins only class-equal slots; bare pairs only with bare)`);
+                throw errors.new(`${label}: ${cond.op.kind}(${cond.lhs.ref.label}, ${cond.rhs.ref.label}) unifies domain-unequal fields — ${cond.lhs.ref.label} bound at ${renderFieldKind(lhs)}, ${cond.rhs.ref.label} at ${renderFieldKind(rhs)} (a var joins only class-equal slots; bare pairs only with bare)`);
             }
         }
         return;
@@ -565,20 +522,18 @@ function validateCond(context, bound, cond) {
     }
 }
 /**
- * Validates one `idb` item: every head column of the rec is bound exactly
+ * Validates one interior item: every head column of the table is bound exactly
  * once (a missing or extra key is a pointed error) and each variable joins
- * its head column's classed slot. A POSITIVE idb atom GROUNDS its
+ * its head column's classed slot. A POSITIVE interior atom GROUNDS its
  * variables (a positive occurrence, exactly the engine's representation),
  * so no boundness precondition exists; a NEGATED one binds nothing — its
  * variables must be positively bound elsewhere in the rule, the same
- * safety rule as EDB negation. When the rec's own rule 0 is in flight
- * (`rec.rules[0]` absent), the completing rule's OWN find columns ARE the
- * head.
+ * safety rule as EDB negation. When the table's own first rule is in flight
+ * (`finds` empty), the completing rule's OWN find columns ARE the head.
  */
-function validateIdb(context, bound, item, columns) {
+function validateInterior(context, bound, item, columns) {
     const label = contextLabel(context);
-    const head = item.rec.rules[0];
-    const headColumns = head !== undefined ? head.finds : columns;
+    const headColumns = item.target.finds.length > 0 ? item.target.finds : columns;
     const headNames = headColumns.map(function nameOf(column) {
         return column.name;
     });
@@ -587,17 +542,17 @@ function validateIdb(context, bound, item, columns) {
     });
     for (const key of keys) {
         if (!headNames.includes(key)) {
-            throw errors.new(`${label}: idb ${item.rec.name} binds ${key}, not a head column of ${item.rec.name} (head columns: ${headNames.join(", ")})`);
+            throw errors.new(`${label}: interior ${item.target.name} binds ${key}, not a head column of ${item.target.name} (head columns: ${headNames.join(", ")})`);
         }
     }
     for (const name of headNames) {
         if (!keys.includes(name)) {
-            throw errors.new(`${label}: idb ${item.rec.name} omits the head column ${name} — an idb join binds every head column of ${item.rec.name}`);
+            throw errors.new(`${label}: interior ${item.target.name} omits the head column ${name} — an interior join binds every head column of ${item.target.name}`);
         }
     }
     for (const binding of item.bindings) {
-        if (item.negated && !bound.has(binding.ref)) {
-            throw errors.new(`${label}: negated idb ${item.rec.name} names the variable ${binding.ref.label}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`);
+        if (item.kind === "negatedInterior" && !bound.has(binding.ref)) {
+            throw errors.new(`${label}: negated interior ${item.target.name} names the variable ${binding.ref.label}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`);
         }
         const headColumn = headColumns.find(function byName(column) {
             return column.name === binding.key;
@@ -607,14 +562,14 @@ function validateIdb(context, bound, item, columns) {
         }
         const mint = mintSlotOf(context, binding.ref);
         if (!fieldJoins(headColumn.slot, mint)) {
-            throw errors.new(`${label}: idb ${item.rec.name} joins the variable ${binding.ref.label} (${renderFieldKind(mint)}) at head column ${binding.key} (${renderFieldKind(headColumn.slot)}) — a var joins only class-equal slots; bare pairs only with bare`);
+            throw errors.new(`${label}: interior ${item.target.name} joins the variable ${binding.ref.label} (${renderFieldKind(mint)}) at head column ${binding.key} (${renderFieldKind(headColumn.slot)}) — a var joins only class-equal slots; bare pairs only with bare`);
         }
     }
 }
 /**
  * Completes one rule: enriches the find columns (declaration-order-safe
  * keys, boundness validated, each column's classed slot and closed slice
- * resolved), then walks the body walls — negated-atom boundness safety, idb
+ * resolved), then walks the body walls — negated-atom boundness safety, interior
  * head pairing, and condition validation.
  */
 function completeRule(context, state, rawColumns) {
@@ -636,8 +591,8 @@ function completeRule(context, state, rawColumns) {
                 }
             }
         }
-        if (item.kind === "idb") {
-            validateIdb(context, state.bound, item, columns);
+        if (item.kind === "interior" || item.kind === "negatedInterior") {
+            validateInterior(context, state.bound, item, columns);
         }
         if (item.kind === "cond") {
             validateCond(context, state.bound, item.cond);
@@ -654,56 +609,65 @@ function contextLabel(context) {
     switch (context.kind) {
         case "query":
             return "query rule";
-        case "rec":
-            return `rec ${context.self.name} rule`;
-        case "output":
-            return "program output rule";
+        case "interior":
+            return `interior ${context.self} rule`;
+        case "rec-base":
+            return `recursive ${context.self.name} base`;
+        case "rec-arm":
+            return `recursive ${context.self.name} rec`;
     }
 }
-/** Validates and records one `idb` atom per the context's cut. */
-function idbAdvance(context, state, target, bindings) {
-    if (context.kind === "query") {
-        throw errors.new("idb is a program construct — declare recs and outputs through program(), never a plain query()");
-    }
-    if (context.kind === "rec") {
-        if (target.data !== context.self) {
-            throw errors.new(`rec ${context.self.name}: a recursive rule's idb target must be the rec itself — the self-recursion-only cut (mutual recursion is unwritable; fold a finished stratum in the output rules)`);
+/** Resolves a derived-table name against the context's visible tables. */
+function lookupDerived(context, name) {
+    const interior = context.interiors.find(function byName(candidate) {
+        return candidate.name === name;
+    });
+    if (interior !== undefined) {
+        if (context.kind === "interior" && name === context.self) {
+            throw errors.new(`interior ${name}: an interior does not read itself — declaration order is topological (a self-read is InteriorNotPrior)`);
         }
-        return advanceIdb(state, context.self, bindings, false);
+        return interior;
     }
-    if (!context.program.recs.includes(target.data)) {
-        throw errors.new(`idb ${target.name}: the rec was declared by a different program — rec identity is the membership rule`);
+    if (context.rec !== null && context.rec.name === name) {
+        if (context.kind === "interior") {
+            throw errors.new(`interior ${context.self}: interiors cannot read the rec — this cut's interiors are a prefix`);
+        }
+        if (context.kind === "rec-base") {
+            throw errors.new(`recursive ${context.rec.name}: a base arm does not read the rec — self-atoms belong on rec arms`);
+        }
+        if (!("finds" in context.rec)) {
+            throw errors.new(`recursive ${context.rec.name}: rec arms resolve the rec head after base arms seal it`);
+        }
+        return context.rec;
     }
-    return advanceIdb(state, target.data, bindings, false);
+    throw errors.new(`${contextLabel(context)}: no derived table named ${name} is in scope`);
+}
+/** Validates and records one interior atom per the context's cut. */
+function interiorAdvance(context, state, name, bindings) {
+    return advanceInterior(state, lookupDerived(context, name), bindings, "interior");
 }
 /**
- * Validates and records one NEGATED finished-stratum atom — output rules
- * only: there every rec is a finished set before the output's operator
- * runs (negation OF lower strata is engine-legal; the strata judge refuses
- * only negation *through* a cycle, which the rec-context refusal here
- * makes unwritable).
+ * Validates and records one NEGATED finished-table atom — main and interior
+ * rules: a finished set is a set. Rec bodies refuse every negation
+ * (`NegationInRec` — self is the wall; EDB / earlier-interior is this-cut).
  */
-function notIdbAdvance(context, state, target, bindings) {
-    if (context.kind === "query") {
-        throw errors.new("idb is a program construct — declare recs and outputs through program(), never a plain query()");
+function notInteriorAdvance(context, state, name, bindings) {
+    if (context.kind === "rec-base" || context.kind === "rec-arm") {
+        throw errors.new(`recursive ${context.self.name}: a recursive rule negates no table — self-negation is negation through the cycle (a finished set is what keeps the operator monotone), and a finished table's fold belongs in the main rules`);
     }
-    if (context.kind === "rec") {
-        throw errors.new(`rec ${context.self.name}: a recursive rule negates no stratum — self-negation is negation through the cycle (a finished set is what keeps the operator monotone), and a finished stratum's fold belongs in the output rules`);
-    }
-    if (!context.program.recs.includes(target.data)) {
-        throw errors.new(`idb ${target.name}: the rec was declared by a different program — rec identity is the membership rule`);
-    }
-    return advanceIdb(state, target.data, bindings, true);
+    return advanceInterior(state, lookupDerived(context, name), bindings, "negatedInterior");
 }
-/** Classifies one find record per the context (a recursive head projects bound variables only). */
+/** Classifies one find record per the context (interior and rec heads project bound variables only). */
 function findColumns(context, entries) {
     const columns = [];
+    const derivedHead = context.kind !== "query";
     for (const [name, entry] of Object.entries(entries)) {
         if (entry === undefined) {
             continue;
         }
-        if (context.kind === "rec" && !(isTerm(entry) && entry[term] === "var")) {
-            throw errors.new(`rec ${context.self.name}: a recursive head projects bound variables only — aggregates and the measure read finished sets (the strata judge's quarantine, unwritable here)`);
+        if (derivedHead && !(isTerm(entry) && entry[term] === "var")) {
+            const who = context.kind === "interior" ? `interior ${context.self}` : `recursive ${context.self.name}`;
+            throw errors.new(`${who}: a recursive head projects bound variables only — aggregates and the measure read finished sets (unwritable here)`);
         }
         columns.push(findColumnOf(name, entry));
     }
@@ -718,8 +682,8 @@ function makeRawChain(context, state) {
         where(cond) {
             return makeRawChain(context, advanceWhere(context, state, cond));
         },
-        idb(target, bindings) {
-            return makeRawChain(context, idbAdvance(context, state, target, bindings));
+        interior(name, bindings) {
+            return makeRawChain(context, interiorAdvance(context, state, name, bindings));
         },
         find(entries) {
             return makeRuleValue(completeRule(context, state, findColumns(context, entries)));
@@ -735,8 +699,8 @@ function makeRawScope(context) {
         match(relation, bindings) {
             return makeRawChain(context, advanceMatch(context, EMPTY_RULE, relation, bindings));
         },
-        idb(target, bindings) {
-            return makeRawChain(context, idbAdvance(context, EMPTY_RULE, target, bindings));
+        interior(name, bindings) {
+            return makeRawChain(context, interiorAdvance(context, EMPTY_RULE, name, bindings));
         }
     };
     Object.freeze(scope);
@@ -755,18 +719,39 @@ function isTypedScope(scope) {
     return typeof scope.match === "function";
 }
 /** Builds one query-rule builder (the typed face of the raw builder). */
-function makeQueryRuleScope(theory) {
-    const raw = makeRawScope({ kind: "query", classes: theory.classes, theory });
+function makeQueryRuleScope(theory, env) {
+    const raw = makeRawScope({ kind: "query", classes: theory.classes, theory, ...env });
     if (!isTypedScope(raw)) {
         throw errors.new("query rule builder construction incomplete");
     }
     return raw;
 }
-/** Builds one output-rule builder over a program's recs. */
-function makeOutputRuleScope(program) {
-    const raw = makeRawScope({ kind: "output", program, classes: program.classes, theory: program.theory });
+/** Builds one interior-rule builder. */
+function makeInteriorRuleScope(theory, env, self) {
+    const raw = makeRawScope({ kind: "interior", self, classes: theory.classes, theory, ...env });
     if (!isTypedScope(raw)) {
-        throw errors.new("program output rule builder construction incomplete");
+        throw errors.new("interior rule builder construction incomplete");
+    }
+    return raw;
+}
+function makeRecRuleScope(theory, env, self, kind) {
+    const raw = kind === "rec-base"
+        ? makeRawScope({
+            kind: "rec-base",
+            self: self,
+            classes: theory.classes,
+            theory,
+            ...env
+        })
+        : makeRawScope({
+            kind: "rec-arm",
+            self: self,
+            classes: theory.classes,
+            theory,
+            ...env
+        });
+    if (!isTypedScope(raw)) {
+        throw errors.new("recursive rule builder construction incomplete");
     }
     return raw;
 }
@@ -784,9 +769,6 @@ function headSignature(column) {
     if (agg.op === "fold") {
         return `${column.name}:${agg.fold}`;
     }
-    if (agg.op === "arg") {
-        return `${column.name}:${agg.direction}`;
-    }
     return `${column.name}:${agg.op}`;
 }
 /** The roster a param anchor carries: present exactly on a closed-reference field anchor. */
@@ -798,17 +780,18 @@ function renderParamAnchor(roster) {
     return roster === undefined ? "a non-closed position" : `a ${roster.name} reference`;
 }
 /**
- * Folds every rule's param uses (recs in declaration order first, output
- * rules last — exactly the lowering walk) into the query's registry: first
- * use mints the dense `ParamId`, the first FIELD-ANCHORED use types the
- * wire, and one name keeps one shape AND one closedness. The orderable
- * ban needs no registry arm: an order use always anchors its SIBLING's
- * domain (the no-variable-side spelling is refused at the comparison
- * constructor), so a closed-anchored param under an order op dies at the
- * one-domain wall here — and an order use whose sibling is itself
- * closed-bound dies at the comparison's own var-side wall first.
+ * Folds every rule's param uses (interiors in declaration order, then rec
+ * base, then rec arms, then main — exactly the lowering walk) into the
+ * query's registry: first use mints the dense `ParamId`, the first
+ * FIELD-ANCHORED use types the wire, and one name keeps one shape AND one
+ * closedness. The orderable ban needs no registry arm: an order use always
+ * anchors its SIBLING's domain (the no-variable-side spelling is refused
+ * at the comparison constructor), so a closed-anchored param under an
+ * order op dies at the one-domain wall here — and an order use whose
+ * sibling is itself closed-bound dies at the comparison's own var-side
+ * wall first.
  */
-function paramRegistryOf(recs, rules) {
+function paramRegistryOf(interiors, rec, rules) {
     const order = [];
     const byName = new Map();
     function fold(uses) {
@@ -843,8 +826,16 @@ function paramRegistryOf(recs, rules) {
             }
         }
     }
-    for (const rec of recs) {
-        for (const rule of rec.rules) {
+    for (const interior of interiors) {
+        for (const rule of interior.rules) {
+            fold(rule.paramUses);
+        }
+    }
+    if (rec !== null) {
+        for (const rule of rec.base) {
+            fold(rule.paramUses);
+        }
+        for (const rule of rec.rec) {
             fold(rule.paramUses);
         }
     }
@@ -880,93 +871,185 @@ function paramRegistryOf(recs, rules) {
         return Object.freeze({ name, shape: entry.shape, anchor: entry.anchor, op: entry.op, membership });
     }));
 }
-/**
- * Assembles the runtime query value over completed rules: every rule must
- * derive the SAME head (name and aggregate shape, position for position —
- * the decode labels and the engine's alignment rule agree), and the param
- * registry folds in program-walk order.
- */
-function makeRawQuery(theory, recs, rules) {
+/** Asserts every rule in a list derives the same head (name, aggregate shape, closed slice, class). */
+function assertAlignedHeads(label, rules) {
     const first = rules[0];
     if (first === undefined) {
-        throw errors.new("a query needs at least one rule");
+        throw errors.new(`${label} needs at least one rule`);
     }
     const signature = first.finds.map(headSignature).join(", ");
     rules.forEach(function verifyHead(rule, index) {
         const candidate = rule.finds.map(headSignature).join(", ");
         if (candidate !== signature) {
-            throw errors.new(`every rule of a query derives the same head — rule 0 finds (${signature}), rule ${index} finds (${candidate})`);
+            throw errors.new(`every rule of ${label} derives the same head — rule 0 finds (${signature}), rule ${index} finds (${candidate})`);
         }
-        // The closed slice is part of the head too: one answer column decodes
-        // through one roster, so a union whose rules bind a column at different
-        // vocabularies (or one closed, one bare) is refused pointed.
         rule.finds.forEach(function verifyClosedSlice(column, position) {
             const lead = first.finds[position];
             if (lead !== undefined && column.closed !== lead.closed) {
-                throw errors.new(`every rule of a query derives the same head — the answer column ${lead.name} is ${renderClosedSlice(lead.closed)} in rule 0 but ${renderClosedSlice(column.closed)} in rule ${index} (one column decodes through one roster)`);
+                throw errors.new(`every rule of ${label} derives the same head — the head column ${lead.name} is ${renderClosedSlice(lead.closed)} in rule 0 but ${renderClosedSlice(column.closed)} in rule ${index} (one column decodes through one roster)`);
             }
-            // The law-class wall on the union head: one answer column is one
-            // value space, so the classed mint slot each rule binds the column
-            // at must join across rules — the SAME fieldJoins judgment every
-            // join/eq/negated-atom position enforces (the SDK holds it because
-            // the wire IR carries no domains).
             if (lead === undefined) {
                 return;
             }
             if (lead.slot !== undefined && column.slot !== undefined && !fieldJoins(lead.slot, column.slot)) {
-                throw errors.new(`every rule of a query derives the same head — the answer column ${lead.name} unions domain-unequal fields: bound at ${renderFieldKind(lead.slot)} in rule 0 but at ${renderFieldKind(column.slot)} in rule ${index} (a union column joins only class-equal slots; bare pairs only with bare)`);
+                throw errors.new(`every rule of ${label} derives the same head — the head column ${lead.name} is bound at ${renderFieldKind(lead.slot)} in rule 0 but at ${renderFieldKind(column.slot)} in rule ${index} (a head column joins only class-equal slots; bare pairs only with bare)`);
             }
         });
     });
+}
+function afterMainError(what) {
+    return errors.new(`query: ${what} after a main rule is unwritable — declaration order is interiors, then rec, then main`);
+}
+/**
+ * Assembles the runtime query value over completed rules: every rule must
+ * derive the SAME head (name and aggregate shape, position for position —
+ * the decode labels and the engine's alignment rule agree), and the param
+ * registry folds in query-walk order.
+ */
+function makeRawQuery(theory, interiors, rec, rules) {
+    assertAlignedHeads("a query", rules);
+    const first = rules[0];
+    if (first === undefined) {
+        throw errors.new("a query needs at least one rule");
+    }
+    const env = { interiors, rec };
     const data = Object.freeze({
-        recs: Object.freeze([...recs]),
+        interiors: Object.freeze([...interiors]),
+        rec,
         rules: Object.freeze([...rules]),
         finds: first.finds,
-        params: paramRegistryOf(recs, rules)
+        params: paramRegistryOf(interiors, rec, rules)
     });
     const value = {
         schema: theory,
         data,
         rule(build) {
-            const built = build(makeRawScope({ kind: "query", classes: theory.classes, theory }));
-            return makeRawQuery(theory, recs, [...rules, built.rule]);
+            const built = build(makeRawScope({ kind: "query", classes: theory.classes, theory, ...env }));
+            return makeRawQuery(theory, interiors, rec, [...rules, built.rule]);
+        },
+        interior() {
+            throw afterMainError("interior");
+        },
+        recursive() {
+            throw afterMainError("recursive");
         }
     };
     Object.freeze(value);
     return value;
 }
-/**
- * The query values' trusted admission seam (the {@link isTypedScope} pattern):
- * the checkable fact — the value was assembled over the identical theory —
- * is verified before the raw value is admitted at its typed face.
- */
-function isQueryValue(theory, value) {
-    return value.schema === theory;
+function makeQuery(theory, interiors, rec, rules) {
+    return makeRawQuery(theory, interiors, rec, rules);
 }
-/** Assembles one typed query value (rules already completed). */
-function makeQuery(theory, recs, rules) {
-    const raw = makeRawQuery(theory, recs, rules);
-    if (!isQueryValue(theory, raw)) {
-        throw errors.new("query value construction incomplete");
+/** Collects one Interior from its builders. */
+function collectInterior(theory, env, name, builds) {
+    if (builds.length === 0) {
+        throw errors.new(`query: interior ${name} needs at least one rule`);
     }
-    return raw;
+    const rules = builds.map(function buildRule(buildOne) {
+        return buildOne(makeInteriorRuleScope(theory, env, name)).rule;
+    });
+    assertAlignedHeads(`interior ${name}`, rules);
+    const first = rules[0];
+    if (first === undefined) {
+        throw errors.new(`query: interior ${name} needs at least one rule`);
+    }
+    return Object.freeze({ name, finds: first.finds, rules: Object.freeze(rules) });
 }
-/**
- * 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.
- */
-function query(theory) {
+/** Collects the Rec from tagged base/rec builder arrays. */
+function collectRec(theory, interiors, name, baseBuilds, recBuilds) {
+    if (baseBuilds.length === 0) {
+        throw errors.new(`query: recursive ${name} has no base arms`);
+    }
+    if (recBuilds.length === 0) {
+        throw errors.new(`query: recursive ${name} has no rec arms`);
+    }
+    const handle = Object.freeze({ name });
+    const baseEnv = { interiors, rec: handle };
+    const base = baseBuilds.map(function buildBase(buildOne) {
+        return buildOne(makeRecRuleScope(theory, baseEnv, handle, "rec-base")).rule;
+    });
+    assertAlignedHeads(`recursive ${name}`, base);
+    const first = base[0];
+    if (first === undefined) {
+        throw errors.new(`query: recursive ${name} has no base arms`);
+    }
+    const firstFind = first.finds[0];
+    if (firstFind === undefined) {
+        throw errors.new(`query: recursive ${name} has no head`);
+    }
+    const finds = [firstFind, ...first.finds.slice(1)];
+    const head = Object.freeze({ name, finds });
+    const recEnv = { interiors, rec: head };
+    const rec = recBuilds.map(function buildRec(buildOne) {
+        return buildOne(makeRecRuleScope(theory, recEnv, head, "rec-arm")).rule;
+    });
+    assertAlignedHeads(`recursive ${name}`, [...base, ...rec]);
+    const firstRec = rec[0];
+    if (firstRec === undefined) {
+        throw errors.new(`query: recursive ${name} has no rec arms`);
+    }
+    const sealedBase = [first, ...base.slice(1)];
+    const sealedRec = [firstRec, ...rec.slice(1)];
+    const recData = Object.freeze({
+        name,
+        finds,
+        base: sealedBase,
+        rec: sealedRec
+    });
+    return recData;
+}
+/** Builds the query start (interiors, then optional rec, then the first main rule). */
+function makeQueryStart(theory, interiors, rec) {
+    const env = { interiors, rec };
     const start = {
+        interior(name, ...builds) {
+            if (rec !== null) {
+                throw errors.new("query: interior after recursive is unwritable — declaration order is interiors, then rec, then main");
+            }
+            if (interiors.some(function sameName(interior) {
+                return interior.name === name;
+            })) {
+                throw errors.new(`query: interior ${name} is already declared — names are unique`);
+            }
+            if (name.length === 0) {
+                throw errors.new("query: an interior needs a name");
+            }
+            const data = collectInterior(theory, env, name, builds);
+            return makeQueryStart(theory, [...interiors, data], null);
+        },
+        recursive(name, arms) {
+            if (rec !== null) {
+                throw errors.new("query: a second recursive is unwritable — this cut admits one linear rec");
+            }
+            if (interiors.some(function sameName(interior) {
+                return interior.name === name;
+            })) {
+                throw errors.new(`query: interior and recursive share the name ${name}`);
+            }
+            if (name.length === 0) {
+                throw errors.new("query: recursive needs a name");
+            }
+            const data = collectRec(theory, interiors, name, arms.base, arms.rec);
+            return makeQueryStart(theory, interiors, data);
+        },
         rule(build) {
-            const built = build(makeQueryRuleScope(theory));
-            return makeQuery(theory, [], [built.rule]);
+            const built = build(makeQueryRuleScope(theory, env));
+            return makeQuery(theory, interiors, rec, [built.rule]);
         }
     };
     Object.freeze(start);
     return start;
 }
+/**
+ * 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.
+ */
+function query(theory) {
+    return makeQueryStart(theory, [], null);
+}
 /**
  * Tags one closed-reference literal: the handle NAME, verified against the
  * roster and translated to its declaration-order row id, tagged u64. THE
@@ -1141,30 +1224,29 @@ function lowerBindingTerm(ctx, context, binding, ids) {
     }
 }
 /**
- * Lowers one idb atom: named bindings placed by HEAD order, `FieldId(i)` =
- * head position i. Every head column of the rec must be bound (a missing key
+ * Lowers one interior atom: named bindings placed by HEAD order, `FieldId(i)` =
+ * head position i. Every head column of the table must be bound (a missing key
  * is refused pointed); the var-id assignment order is head order, so the
  * first-use numbering matches the name-keyed edition exactly.
  */
-function lowerIdbAtom(ctx, rec, bindings, ids) {
-    const pred = ctx.recIds.get(rec);
-    if (pred === undefined) {
-        throw errors.new(`query lowering: rec ${rec.name} was declared by a different program`);
+function lowerInteriorAtom(ctx, target, bindings, ids) {
+    const interior = ctx.interiorIds.get(target.name);
+    if (interior === undefined) {
+        throw errors.new(`query lowering: derived table ${target.name} was not declared on this query`);
     }
-    const head = rec.rules[0];
-    if (head === undefined) {
-        throw errors.new(`query lowering: rec ${rec.name} has no rules`);
+    if (target.finds.length === 0) {
+        throw errors.new(`query lowering: derived table ${target.name} has no head`);
     }
-    const irBindings = head.finds.map(function lowerPosition(column, position) {
+    const irBindings = target.finds.map(function lowerPosition(column, position) {
         const binding = bindings.find(function byKey(candidate) {
             return candidate.key === column.name;
         });
         if (binding === undefined) {
-            throw errors.new(`query lowering: idb ${rec.name} omits head column ${column.name}`);
+            throw errors.new(`query lowering: interior ${target.name} omits head column ${column.name}`);
         }
         return [position, { kind: "var", var: ids.of(binding.ref) }];
     });
-    return { source: { kind: "idb", pred }, bindings: irBindings };
+    return { source: { kind: "interior", interior }, bindings: irBindings };
 }
 /** Lowers one comparison side; literals tag by the sibling's anchor (op-aware at `pointIn`). */
 function lowerCmpTerm(ctx, side, sibling, ids, op) {
@@ -1201,24 +1283,17 @@ function cmpAnchorOf(ctx, sibling) {
 }
 /** Lowers one comparison. */
 function lowerComparison(ctx, cmp, ids) {
-    if (cmp.op === "allen") {
-        const maskData = cmp.mask;
-        if (maskData === undefined) {
-            throw errors.new("query lowering: an allen comparison lost its mask");
-        }
-        const mask = maskData.kind === "literal"
-            ? { kind: "literal", mask: maskData.mask }
-            : { kind: "param", param: paramIdOf(ctx, maskData.name) };
+    if (cmp.op.kind === "allen") {
         return {
-            op: { kind: "allen", mask },
+            op: { kind: "allen", mask: cmp.op.mask },
             lhs: lowerCmpTerm(ctx, cmp.lhs, cmp.rhs, ids, "allen"),
             rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, "allen")
         };
     }
     return {
-        op: { kind: cmp.op },
-        lhs: lowerCmpTerm(ctx, cmp.lhs, cmp.rhs, ids, cmp.op),
-        rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, cmp.op)
+        op: { kind: cmp.op.kind },
+        lhs: lowerCmpTerm(ctx, cmp.lhs, cmp.rhs, ids, cmp.op.kind),
+        rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, cmp.op.kind)
     };
 }
 /** Lowers one condition node (comparison leaf or and/or tree). */
@@ -1245,16 +1320,12 @@ function lowerFind(entry, ids) {
     switch (agg.op) {
         case "count":
             return { kind: "aggregate", op: { kind: "count" } };
-        case "countDistinct":
-            return { kind: "aggregate", op: { kind: "countDistinct" }, over: ids.of(agg.over) };
         case "fold": {
             if ("duration" in agg.over) {
                 return { kind: "aggregateMeasure", op: { kind: agg.fold }, over: ids.of(agg.over.duration) };
             }
             return { kind: "aggregate", op: { kind: agg.fold }, over: ids.of(agg.over) };
         }
-        case "arg":
-            return { kind: "aggregate", op: { kind: agg.direction, key: ids.of(agg.key) }, over: ids.of(agg.over) };
         case "pack":
             return { kind: "aggregate", op: { kind: "pack" }, over: ids.of(agg.over) };
     }
@@ -1264,12 +1335,8 @@ function headOpOf(agg) {
     switch (agg.op) {
         case "count":
             return "count";
-        case "countDistinct":
-            return "countDistinct";
         case "fold":
             return agg.fold;
-        case "arg":
-            return agg.direction;
         case "pack":
             return "pack";
     }
@@ -1298,9 +1365,12 @@ function lowerRule(ctx, rule) {
                 negated.push(lowerAtom(ctx, item.atom, ids));
                 break;
             }
-            case "idb": {
-                const bucket = item.negated ? negated : atoms;
-                bucket.push(lowerIdbAtom(ctx, item.rec, item.bindings, ids));
+            case "interior": {
+                atoms.push(lowerInteriorAtom(ctx, item.target, item.bindings, ids));
+                break;
+            }
+            case "negatedInterior": {
+                negated.push(lowerInteriorAtom(ctx, item.target, item.bindings, ids));
                 break;
             }
             case "cond": {
@@ -1319,9 +1389,9 @@ function lowerRule(ctx, rule) {
     };
 }
 /**
- * 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.
  */
 function lowerQuery(q) {
     const theory = q.schema;
@@ -1329,39 +1399,48 @@ function lowerQuery(q) {
     Object.keys(theory.relations).forEach(function assignOrdinal(name, index) {
         relationIds.set(name, index);
     });
-    const recIds = new Map();
-    q.data.recs.forEach(function assignPredId(rec, index) {
-        recIds.set(rec, index);
+    const interiorIds = new Map();
+    q.data.interiors.forEach(function assignInteriorId(interior, index) {
+        interiorIds.set(interior.name, index);
     });
+    if (q.data.rec !== null) {
+        interiorIds.set(q.data.rec.name, q.data.interiors.length);
+    }
     const paramIds = new Map();
     const params = new Map();
     q.data.params.forEach(function assignParamId(entry, index) {
-        if (entry.anchor === undefined && entry.shape !== "mask") {
+        if (entry.anchor === undefined) {
             throw errors.new(`query param ${entry.name} has no field-anchored use — bind it in an atom or compare it against a bound variable`);
         }
         paramIds.set(entry.name, index);
         params.set(entry.name, entry);
     });
-    const ctx = { theory, relationIds, recIds, paramIds, params };
-    const predicates = q.data.recs.map(function lowerRec(rec) {
-        const head = rec.rules[0];
-        if (head === undefined) {
-            throw errors.new(`query lowering: rec ${rec.name} has no rules`);
-        }
-        return {
-            head: head.finds.map(headTermOf),
-            rules: rec.rules.map(function lowerRecRule(rule) {
-                return lowerRule(ctx, rule);
-            })
-        };
-    });
-    predicates.push({
+    const ctx = { theory, relationIds, interiorIds, paramIds, params };
+    return parseQueryIr({
+        interiors: q.data.interiors.map(function lowerInterior(interior) {
+            return {
+                head: interior.finds.map(headTermOf),
+                rules: interior.rules.map(function lowerInteriorRule(rule) {
+                    return lowerRule(ctx, rule);
+                })
+            };
+        }),
+        rec: q.data.rec === null
+            ? null
+            : {
+                head: q.data.rec.finds.map(headTermOf),
+                base: q.data.rec.base.map(function lowerBase(rule) {
+                    return lowerRule(ctx, rule);
+                }),
+                rec: q.data.rec.rec.map(function lowerRecArm(rule) {
+                    return lowerRule(ctx, rule);
+                })
+            },
         head: q.data.finds.map(headTermOf),
-        rules: q.data.rules.map(function lowerOutputRule(rule) {
+        rules: q.data.rules.map(function lowerMainRule(rule) {
             return lowerRule(ctx, rule);
         })
     });
-    return { predicates, output: q.data.recs.length };
 }
-export { lowerQuery, makeOutputRuleScope, makeQuery, makeRawScope, query, taggedCmpLiteral, taggedLiteral };
+export { lowerQuery, makeRawScope, query, taggedCmpLiteral, taggedLiteral };
 //# sourceMappingURL=lower.js.map