@bjornpagen/bumbledb 0.1.0 → 0.3.0

package/dist/query/lower.js

@@ -1,156 +1,717 @@
 /**
- * `query()` and the IR lowering (PRD-08). A query is built inside a scope
- * callback (variable identity is lexical and typed) and is an INERT value:
- * `Query<Rels, Row, Params>` with `Row` inferred from `select` and
- * `Params` from every parameter the returned rules (and the predicates
- * they reach) use. Lowering is a pure function of the query value down to
- * the bridge's `ProgramIr` (`bumbledb/crates/bumbledb/src/ir.rs`, the
- * bijection target): relations and predicates by declaration ordinal (the
- * declaration-order-is-ids law the engine's manifest pins), variables by
- * dense per-rule first-occurrence ids (rule-scoped, exactly as the IR
- * scopes them), params by scope declaration order. Lowering is STABLE —
- * the same query value lowers to deeply-equal IR every time, and two
- * identically-written queries lower identically (prepared-query caching
- * upstream keys on this). Construction validates negation safety (typed,
- * naming the variable — earlier and warmer than the engine's refusal);
- * everything else (strata, types, aggregates rosters, rule caps) is the
- * ENGINE's judge, surfacing its typed errors at prepare. No invented
- * limits: rule counts and predicate counts are never pre-checked here.
+ * `query()` and the IR lowering, STRUCTURAL edition. A query is built
+ * kysely-shaped — `query(S).rule(r => r.match(Rel, { f: r.var("x") })
+ * .where(r.eq(r.var("x"), r.param("p"))).select("x"))` — and is an INERT
+ * value: `Query<Rels, Row, Params>` with `Row` inferred from each rule's
+ * `.select` and `Params` inferred to be EXACTLY the params the rules use
+ * (params are typed BY USE; a param value no rule uses never registers, so
+ * every query executes under its own inferred type). Vars are string
+ * names, domain-typed by the field they first bind and joined by reuse —
+ * the rule builder's environment carries name → field descriptor through
+ * the chain, checked structurally at every reuse (`JoinOk`), so the old
+ * brand-equal join is now the domain-equal compile error. Lowering is a
+ * pure function of the query value down to the bridge's `ProgramIr`
+ * (`bumbledb/crates/bumbledb/src/ir.rs`, the bijection target): relations
+ * by declaration ordinal (the declaration-order-is-ids law the engine's
+ * manifest pins), variables by dense per-rule first-occurrence ids
+ * (rule-scoped, exactly as the IR scopes them), params by first-use order
+ * across the program walk. Lowering is STABLE — the same query value
+ * lowers to deeply-equal IR every time, and two identically-written
+ * queries lower identically. Construction validates negation safety and
+ * name-boundness (typed, naming the variable — earlier and warmer than
+ * the engine's refusal); everything else (strata, types, aggregate
+ * rosters, rule caps) is the ENGINE's judge, surfacing its typed errors
+ * at prepare. No invented limits: rule and predicate counts are never
+ * pre-checked here.
  */
 import * as errors from "@superbuilders/errors";
-import { phantom } from "#brand.ts";
 import { assertDeclarationOrderKey } from "#fields.ts";
-import { makePredicate } from "#query/predicate.ts";
-import { createRegistry, isTerm, scopeAllenParam, scopeParam, scopeParamSet, scopeVar, term } from "#query/scope.ts";
+import { allen, and, covers, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts";
+import { fieldJoins, inferred, isTerm, makeDuration, makeMaskParam, makeParam, makeSetParam, makeVar, makeVars, renderFieldKind, term } from "#query/scope.ts";
+import { argMax, argMin, count, countDistinct, max, min, pack, sum } from "#query/select.ts";
+/** The frozen constructor vocabulary every rule builder spreads. */
+const termOps = Object.freeze({
+    var: makeVar,
+    vars: makeVars,
+    param: makeParam,
+    inSet: makeSetParam,
+    maskParam: makeMaskParam,
+    duration: makeDuration,
+    eq,
+    ne,
+    lt,
+    le,
+    gt,
+    ge,
+    pointIn,
+    covers,
+    allen,
+    and,
+    or,
+    not,
+    count,
+    countDistinct,
+    sum,
+    min,
+    max,
+    argMax,
+    argMin,
+    pack
+});
+/** The empty rule state. */
+const EMPTY_RULE = Object.freeze({
+    items: Object.freeze([]),
+    varFields: Object.freeze({}),
+    paramUses: Object.freeze([])
+});
 /**
- * Narrows an aggregate select value — a trusted seam over the surface's
- * own constructors (only `#query/select.ts` produces `aggregate`-carrying
- * values), the same direction as every other constructor-owned shape here.
+ * The ordered matchable fields of an atom owner — the runtime twin of the
+ * type tier's `MatchFields`: a relation's declared fields; a closed
+ * relation's SEALED shape, the synthetic `id` (the value's own
+ * roster-carrying descriptor, by identity) at ordinal 0 and the declared
+ * payload columns at declared index + 1 (the sealed shift, mirroring
+ * `spec.rs`'s resolver — a `ClosedColumn` is structurally a
+ * {@link RelationField}). The lowering golden pins this mapping.
  */
-function isAggregateEntry(value) {
-    return "aggregate" in value;
+function matchFieldsOf(owner) {
+    if ("axioms" in owner) {
+        return [Object.freeze({ name: "id", field: owner.id }), ...owner.data.columns];
+    }
+    return owner.data.fields;
 }
-/** Narrows a `duration()` select value (only `duration` produces `measure`). */
-function isMeasureEntry(value) {
-    return "measure" in value;
+/**
+ * Resolves a bindings record against an atom owner's matchable fields (a
+ * relation's declared fields; a closed relation's sealed id + columns), in
+ * the record's written order: terms classify by their runtime tag,
+ * everything else is a bare literal (typed by the FIELD at lowering — the
+ * membership typing rule included). Every bound field carries its
+ * law-computed class, read off the schema value's frozen class map — the
+ * runtime twin of the type tier's `SlotAt` lookups.
+ */
+function resolveBindings(context, relation, bindings, classes) {
+    const entries = [];
+    const vars = [];
+    const uses = [];
+    const relationClasses = classes[relation.name];
+    const ordered = matchFieldsOf(relation);
+    for (const [fieldName, value] of Object.entries(bindings)) {
+        if (value === undefined) {
+            continue;
+        }
+        const declared = ordered.find(function byName(candidate) {
+            return candidate.name === fieldName;
+        });
+        if (declared === undefined) {
+            throw errors.new(`${context} has no field ${fieldName}`);
+        }
+        const fieldClass = relationClasses?.[fieldName];
+        let bound;
+        if (isTerm(value)) {
+            switch (value[term]) {
+                case "var": {
+                    bound = Object.freeze({ kind: "var", name: value.name });
+                    vars.push(Object.freeze({ name: value.name, slot: Object.freeze({ field: declared.field, class: fieldClass }) }));
+                    break;
+                }
+                case "param": {
+                    bound = Object.freeze({ kind: "param", name: value.name });
+                    uses.push(Object.freeze({ name: value.name, shape: "value", anchor: declared.field, op: "binding" }));
+                    break;
+                }
+                case "setParam": {
+                    bound = Object.freeze({ kind: "setParam", name: value.name });
+                    uses.push(Object.freeze({ name: value.name, shape: "set", anchor: declared.field, op: "binding" }));
+                    break;
+                }
+                case "maskParam":
+                    throw errors.new(`${context}.${fieldName}: an Allen-mask param is not a field-typed value — masks live in allen() conditions only`);
+                case "duration":
+                    throw errors.new(`${context}.${fieldName}: the measure is not a field-typed value — it lives in comparisons and select entries`);
+            }
+        }
+        else {
+            bound = Object.freeze({ kind: "literal", value });
+        }
+        entries.push(Object.freeze({ field: fieldName, data: declared.field, class: fieldClass, term: bound }));
+    }
+    return {
+        atom: Object.freeze({ relation, bindings: Object.freeze(entries) }),
+        vars,
+        uses
+    };
 }
-/** Classifies one select record value into its runtime entry. */
-function selectEntryOf(name, value) {
-    if (isTerm(value)) {
-        if (value[term] !== "var") {
-            throw errors.new(`query select column ${name}: a ${value[term]} is not projectable — select takes variables, duration(v), or aggregates`);
+/**
+ * Extends a rule state with one positive atom. Vars bind on first
+ * occurrence; every LATER occurrence (a later atom's field or a same-record
+ * sibling) is a join and must be class-equal — the construction-time twin
+ * of the type tier's `JoinOk` (bare pairs only with bare), so the domain
+ * wall holds for untyped callers too.
+ */
+function advanceMatch(state, relation, bindings, classes) {
+    const resolved = resolveBindings(`relation ${relation.name}`, relation, bindings, classes);
+    const varFields = { ...state.varFields };
+    for (const bound of resolved.vars) {
+        const existing = varFields[bound.name];
+        if (existing === undefined) {
+            varFields[bound.name] = bound.slot;
+        }
+        else if (!fieldJoins(existing, bound.slot)) {
+            throw errors.new(`relation ${relation.name}: the variable ${bound.name} joins domain-unequal fields — first bound at ${renderFieldKind(existing)}, reused at ${renderFieldKind(bound.slot)} (a var joins only class-equal slots; bare pairs only with bare)`);
         }
-        return Object.freeze({ kind: "var", over: value });
     }
-    if (typeof value === "object" && value !== null) {
-        if (isAggregateEntry(value)) {
-            return Object.freeze({ kind: "aggregate", aggregate: value.aggregate });
+    return {
+        items: Object.freeze([...state.items, Object.freeze({ kind: "atom", atom: resolved.atom })]),
+        varFields: Object.freeze(varFields),
+        paramUses: Object.freeze([...state.paramUses, ...resolved.uses])
+    };
+}
+/** Resolves one comparison side to its runtime term. */
+function cmpTermDataOf(op, value) {
+    if (isTerm(value)) {
+        switch (value[term]) {
+            case "var":
+                return Object.freeze({ kind: "var", name: value.name });
+            case "param":
+                return Object.freeze({ kind: "param", name: value.name });
+            case "setParam":
+                return Object.freeze({ kind: "setParam", name: value.name });
+            case "duration":
+                return Object.freeze({ kind: "measure", name: value.name });
+            case "maskParam":
+                throw errors.new(`${op}: an Allen-mask param is not a comparison term — masks live in allen()'s mask position`);
         }
-        if (isMeasureEntry(value)) {
-            return Object.freeze({ kind: "measure", over: value.measure });
+    }
+    return Object.freeze({ kind: "literal", value });
+}
+/**
+ * One comparison side's contribution to the param census: a param/set side
+ * anchors to its SIBLING — a bound variable's field descriptor or the
+ * measure; an unanchorable use (literal or param sibling) records with no
+ * anchor and must be anchored by some other use of the same name.
+ */
+function sideUses(op, side, sibling, varFields, uses) {
+    if (side.kind !== "param" && side.kind !== "setParam") {
+        return;
+    }
+    let anchor;
+    if (sibling.kind === "var") {
+        anchor = varFields[sibling.name]?.field;
+    }
+    else if (sibling.kind === "measure") {
+        anchor = "measure";
+    }
+    else {
+        anchor = undefined;
+    }
+    uses.push(Object.freeze({
+        name: side.name,
+        shape: side.kind === "param" ? "value" : "set",
+        anchor,
+        op
+    }));
+}
+/** Lowers one condition VALUE to its runtime data, recording param uses. */
+function condDataOf(cond, varFields, uses) {
+    if (cond.cond === "cmp") {
+        const lhs = cmpTermDataOf(cond.op, cond.lhs);
+        const rhs = cmpTermDataOf(cond.op, cond.rhs);
+        sideUses(cond.op, lhs, rhs, varFields, uses);
+        sideUses(cond.op, rhs, lhs, varFields, 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" }));
+            }
+            else {
+                throw errors.new("allen: the mask position takes a 13-bit mask number or a maskParam");
+            }
         }
+        const data = Object.freeze({ kind: "cmp", op: cond.op, mask, lhs, rhs });
+        return data;
+    }
+    if (cond.cond === "tree") {
+        const children = cond.children.map(function lowerChild(child) {
+            return condDataOf(child, varFields, uses);
+        });
+        const data = Object.freeze({ kind: "tree", op: cond.op, children: Object.freeze(children) });
+        return data;
     }
-    throw errors.new(`query select column ${name}: not a select entry — select takes variables, duration(v), or aggregates`);
+    throw errors.new("a negated atom is not a condition-tree node — pass not(...) to where() directly, never inside and()/or()");
 }
-/** Renders an atom source's name for construction diagnostics. */
-function sourceName(source) {
-    if (source.kind === "relation") {
-        return source.relation.name;
+/** Extends a rule state with one `.where` item (a condition or a negated atom). */
+function advanceWhere(state, cond, classes) {
+    if (typeof cond !== "object" || cond === null || !("cond" in cond)) {
+        throw errors.new("where() takes a comparison, an and()/or() tree, or a negated atom");
     }
-    return `predicate ${source.pred.name}`;
+    if (cond.cond === "not") {
+        const relation = cond.relation;
+        const bindings = Object.fromEntries(Object.entries(cond.bindings ?? {}).filter(function defined([, value]) {
+            return value !== undefined;
+        }));
+        const resolved = resolveBindings(`negated relation ${relation.name}`, relation, bindings, classes);
+        return {
+            items: Object.freeze([...state.items, Object.freeze({ kind: "negated", atom: resolved.atom })]),
+            varFields: state.varFields,
+            paramUses: Object.freeze([...state.paramUses, ...resolved.uses])
+        };
+    }
+    const uses = [];
+    const data = condDataOf(cond, state.varFields, uses);
+    return {
+        items: Object.freeze([...state.items, Object.freeze({ kind: "cond", cond: data })]),
+        varFields: state.varFields,
+        paramUses: Object.freeze([...state.paramUses, ...uses])
+    };
 }
-/** Collects every variable a rule's positive atoms bind. */
-function positiveVarsOf(body) {
-    const positive = new Set();
-    for (const item of body) {
-        if (item.item !== "atom" || item.negated) {
-            continue;
+/** Extends a rule state with one `idb` atom (vars must be bound — validated at completion). */
+function advanceIdb(state, rec, vars) {
+    const names = vars.map(function nameOf(variable) {
+        if (!isTerm(variable) || variable[term] !== "var") {
+            throw errors.new(`idb ${rec.name}: positions take variables — bind literals and params through where()/match()`);
         }
-        for (const binding of item.bindings) {
-            if (binding.term.kind === "term" && binding.term.value[term] === "var") {
-                positive.add(binding.term.value);
-            }
+        return variable.name;
+    });
+    return {
+        items: Object.freeze([...state.items, Object.freeze({ kind: "idb", rec, vars: Object.freeze(names) })]),
+        varFields: state.varFields,
+        paramUses: state.paramUses
+    };
+}
+/** Narrows a select entry to an aggregate value. */
+function isAggregateEntry(value) {
+    return typeof value === "object" && value !== null && "agg" in value;
+}
+/** Classifies one select entry into its named answer column. */
+function selectColumnOf(entry) {
+    if (typeof entry === "string") {
+        return Object.freeze({ name: entry, entry: Object.freeze({ kind: "var", over: entry }) });
+    }
+    if (isTerm(entry)) {
+        if (entry[term] === "duration") {
+            return Object.freeze({ name: entry.name, entry: Object.freeze({ kind: "measure", over: entry.name }) });
         }
+        throw errors.new(`query select: a ${entry[term]} is not projectable — select takes variable names, duration(v), or aggregates`);
     }
-    return positive;
+    if (isAggregateEntry(entry)) {
+        return aggregateColumnOf(entry);
+    }
+    throw errors.new("query select: not a select entry — select takes variable names, duration(v), or aggregates");
 }
-/** Judges one negated atom against the rule's positively-bound variables. */
-function assertNegatedAtomSafe(context, positive, atom) {
-    for (const binding of atom.bindings) {
-        if (binding.term.kind === "oneOf") {
-            throw errors.new(`${context}: negated ${sourceName(atom.source)} atom binds ${binding.field} with oneOf(...) — its lowering mints a variable no positive atom binds (the safety rule); write one negated atom per literal, or bind a paramSet`);
+/** Classifies one aggregate select entry. */
+function aggregateColumnOf(entry) {
+    function column(name, agg) {
+        return Object.freeze({ name, entry: Object.freeze({ kind: "aggregate", agg: Object.freeze(agg) }) });
+    }
+    const over = entry.over;
+    switch (entry.agg) {
+        case "count":
+            return column("count", { op: "count" });
+        case "countDistinct": {
+            if (typeof over !== "string") {
+                throw errors.new("countDistinct takes a variable name");
+            }
+            return column(over, { op: "countDistinct", over });
         }
-        if (binding.term.kind !== "term" || binding.term.value[term] !== "var") {
-            continue;
+        case "sum":
+        case "min":
+        case "max": {
+            if (typeof over === "string") {
+                return column(over, { op: "fold", fold: entry.agg, over });
+            }
+            if (isTerm(over) && over[term] === "duration") {
+                return column(over.name, { op: "fold", fold: entry.agg, over: Object.freeze({ duration: over.name }) });
+            }
+            throw errors.new(`${entry.agg} takes a variable name or duration(v)`);
+        }
+        case "argMax":
+        case "argMin": {
+            if (typeof over !== "string" || typeof entry.key !== "string") {
+                throw errors.new(`${entry.agg} takes a carried variable name and an orderable key variable name`);
+            }
+            return column(over, { op: "arg", direction: entry.agg, over, key: entry.key });
         }
-        const variable = binding.term.value;
-        if (!positive.has(variable)) {
-            throw errors.new(`${context}: negated ${sourceName(atom.source)} atom binds the variable declared from ${variable.relation}.${variable.field} at position ${binding.field}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`);
+        case "pack": {
+            if (typeof over !== "string") {
+                throw errors.new("pack takes a variable name");
+            }
+            return column(over, { op: "pack", over });
         }
+        default:
+            throw errors.new(`unknown aggregate ${entry.agg}`);
+    }
+}
+/** Requires a var name to be bound by a relation atom of the rule. */
+function assertBound(context, varFields, name) {
+    const slot = varFields[name];
+    if (slot === undefined) {
+        throw errors.new(`${context}: the variable ${name} is not bound by a relation atom of the rule`);
+    }
+    return slot;
+}
+/** Requires a var name to be bound at an interval field (the measure's and pack's domain). */
+function assertIntervalBound(context, varFields, name) {
+    const slot = assertBound(context, varFields, name);
+    if (slot.field.kind !== "interval") {
+        throw errors.new(`${context}: ${name} is not interval-typed — the measure is defined over interval-typed variables only`);
     }
 }
 /**
- * The negation safety rule, judged at construction (earlier and warmer
- * than the engine's refusal, which also stands): every variable a negated
- * atom uses must be bound by a positive atom of the same rule — a negated
- * atom binds nothing, only rejects.
+ * Validates one condition's variable references against the rule's bound
+ * names — and, for `eq`/`ne` over two variables, holds the class wall: the
+ * unification IS a join, so the two slots must be class-equal exactly as a
+ * match-reuse join must be (the construction-time twin of the type tier's
+ * `EqOk` → `JoinOk`; bare pairs only with bare). The engine cannot backstop
+ * this one — the query IR carries no domains — so the wall lives here for
+ * untyped callers too.
  */
-function assertNegationSafety(context, body) {
-    const positive = positiveVarsOf(body);
-    for (const item of body) {
-        if (item.item === "atom" && item.negated) {
-            assertNegatedAtomSafe(context, positive, item);
+function validateCond(context, varFields, cond) {
+    if (cond.kind === "cmp") {
+        for (const side of [cond.lhs, cond.rhs]) {
+            if (side.kind === "var") {
+                assertBound(context, varFields, side.name);
+            }
+            if (side.kind === "measure") {
+                assertIntervalBound(context, varFields, side.name);
+            }
         }
+        if ((cond.op === "eq" || cond.op === "ne") && cond.lhs.kind === "var" && cond.rhs.kind === "var") {
+            const lhs = assertBound(context, varFields, cond.lhs.name);
+            const rhs = assertBound(context, varFields, cond.rhs.name);
+            if (!fieldJoins(lhs, rhs)) {
+                throw errors.new(`${context}: ${cond.op}(${cond.lhs.name}, ${cond.rhs.name}) unifies domain-unequal fields — ${cond.lhs.name} bound at ${renderFieldKind(lhs)}, ${cond.rhs.name} at ${renderFieldKind(rhs)} (a var joins only class-equal slots; bare pairs only with bare)`);
+            }
+        }
+        return;
+    }
+    for (const child of cond.children) {
+        validateCond(context, varFields, child);
+    }
+}
+/** Validates one select column's variable references. */
+function validateColumn(context, varFields, column) {
+    const entry = column.entry;
+    if (entry.kind === "var") {
+        assertBound(`${context} select ${column.name}`, varFields, entry.over);
+        return;
+    }
+    if (entry.kind === "measure") {
+        assertIntervalBound(`${context} select ${column.name}`, varFields, entry.over);
+        return;
+    }
+    const agg = entry.agg;
+    switch (agg.op) {
+        case "count":
+            return;
+        case "countDistinct":
+            assertBound(`${context} select ${column.name}`, varFields, agg.over);
+            return;
+        case "fold": {
+            if (typeof agg.over === "string") {
+                assertBound(`${context} select ${column.name}`, varFields, agg.over);
+                return;
+            }
+            assertIntervalBound(`${context} select ${column.name}`, varFields, agg.over.duration);
+            return;
+        }
+        case "arg":
+            assertBound(`${context} select ${column.name}`, varFields, agg.over);
+            assertBound(`${context} select ${column.name}`, varFields, agg.key);
+            return;
+        case "pack":
+            assertIntervalBound(`${context} select ${column.name}`, varFields, agg.over);
+            return;
     }
 }
 /**
- * Builds a query as a typed value: runs `build` inside a fresh scope,
- * classifies the select record (written order = answer column order),
- * validates negation safety across every rule (the predicates' rules
- * included), and freezes. Rule counts, strata legality, and every deeper
- * roster stay the engine's judge at prepare.
+ * Completes one rule: classifies the select record (written order = answer
+ * column order, names must be declaration-order-safe keys), and validates
+ * boundness — every condition/select/idb variable bound by a relation atom,
+ * and every NEGATED atom's variable positively bound (the safety rule: a
+ * negated atom binds nothing, only rejects).
  */
-function query(theory, build) {
-    const registry = createRegistry(theory);
-    const scope = Object.freeze({
-        var(field) {
-            return scopeVar(registry, field);
-        },
-        param(name, field) {
-            return scopeParam(registry, name, field);
+function completeRule(context, state, columns) {
+    if (columns.length === 0) {
+        throw errors.new(`${context}: a select needs at least one entry`);
+    }
+    const seen = new Set();
+    for (const column of columns) {
+        assertDeclarationOrderKey(`${context} select column`, column.name);
+        if (seen.has(column.name)) {
+            throw errors.new(`${context}: select names the answer column ${column.name} twice`);
+        }
+        seen.add(column.name);
+        validateColumn(context, state.varFields, column);
+    }
+    for (const item of state.items) {
+        if (item.kind === "negated") {
+            for (const binding of item.atom.bindings) {
+                if (binding.term.kind === "var") {
+                    const bound = state.varFields[binding.term.name];
+                    if (bound === undefined) {
+                        throw errors.new(`${context}: negated ${item.atom.relation.name} atom binds the variable ${binding.term.name} at position ${binding.field}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`);
+                    }
+                    const negatedSlot = { field: binding.data, class: binding.class };
+                    if (!fieldJoins(bound, negatedSlot)) {
+                        throw errors.new(`${context}: negated ${item.atom.relation.name} atom reuses the variable ${binding.term.name} at ${binding.field} (${renderFieldKind(negatedSlot)}), but the rule binds it at ${renderFieldKind(bound)} — a var joins only class-equal slots; bare pairs only with bare`);
+                    }
+                }
+            }
+        }
+        if (item.kind === "idb") {
+            const head = item.rec.rules[0];
+            item.vars.forEach(function checkIdbVar(name, position) {
+                const bound = state.varFields[name];
+                if (bound === undefined) {
+                    throw errors.new(`${context}: idb ${item.rec.name} names the variable ${name}, but no relation atom of the rule binds it — an idb atom is a join position; bind the variable through the theory's own relation first`);
+                }
+                const column = head?.select[position];
+                if (column === undefined || column.entry.kind !== "var") {
+                    return;
+                }
+                const headSlot = head?.varFields[column.entry.over];
+                if (headSlot !== undefined && !fieldJoins(headSlot, bound)) {
+                    throw errors.new(`${context}: idb ${item.rec.name} joins the variable ${name} (${renderFieldKind(bound)}) at head position ${position} (${column.name}: ${renderFieldKind(headSlot)}) — a var joins only class-equal slots; bare pairs only with bare`);
+                }
+            });
+        }
+        if (item.kind === "cond") {
+            validateCond(context, state.varFields, item.cond);
+        }
+    }
+    return Object.freeze({
+        items: state.items,
+        select: Object.freeze([...columns]),
+        varFields: state.varFields,
+        paramUses: state.paramUses
+    });
+}
+/** Builds one typed rule value over completed rule data. */
+function makeRuleValue(rule) {
+    return Object.freeze({ rule });
+}
+/** The diagnostic label of a chain context. */
+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";
+    }
+}
+/** Validates and records one `idb` atom per the context's cut. */
+function idbAdvance(context, state, target, vars) {
+    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)`);
+        }
+        return advanceIdb(state, context.self, vars);
+    }
+    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, vars);
+}
+/** Classifies one select tuple per the context (a recursive head projects bound NAMES only). */
+function selectColumns(context, entries) {
+    return entries.map(function columnOf(entry) {
+        if (context.kind === "rec" && typeof entry !== "string") {
+            throw errors.new(`rec ${context.self.name}: a recursive head projects bound variable NAMES only — aggregates and the measure read finished sets (the strata judge's quarantine, unwritable here)`);
+        }
+        return selectColumnOf(entry);
+    });
+}
+/** Builds one runtime chain (immutably — every step is a fresh chain over fresh state). */
+function makeRawChain(context, state) {
+    const chain = {
+        match(relation, bindings) {
+            return makeRawChain(context, advanceMatch(state, relation, bindings, context.classes));
         },
-        paramSet(name, field) {
-            return scopeParamSet(registry, name, field);
+        where(cond) {
+            return makeRawChain(context, advanceWhere(state, cond, context.classes));
         },
-        allenParam(name) {
-            return scopeAllenParam(registry, name);
+        idb(target, ...vars) {
+            return makeRawChain(context, idbAdvance(context, state, target, vars));
         },
-        predicate(name, columns, rules) {
-            return makePredicate(registry, name, columns, rules);
+        select(...entries) {
+            return makeRuleValue(completeRule(contextLabel(context), state, selectColumns(context, entries)));
         }
-    });
-    const built = build(scope);
-    const select = [];
-    for (const [name, value] of Object.entries(built.select)) {
-        assertDeclarationOrderKey("query select column", name);
-        select.push(Object.freeze({ name, entry: selectEntryOf(name, value) }));
-    }
-    for (const pred of registry.predicates) {
-        pred.rules.forEach(function validateRule(rule, index) {
-            assertNegationSafety(`query construction (predicate ${pred.name}, rule ${index})`, rule.body);
-        });
+    };
+    Object.freeze(chain);
+    return chain;
+}
+/** Builds one runtime rule-builder over a context. */
+function makeRawScope(context) {
+    const scope = {
+        ...termOps,
+        match(relation, bindings) {
+            return makeRawChain(context, advanceMatch(EMPTY_RULE, relation, bindings, context.classes));
+        }
+    };
+    Object.freeze(scope);
+    return scope;
+}
+/**
+ * The one trusted admission seam of the rule builders (the `relation()`
+ * `refsComplete` pattern): the raw builder is one runtime shape for every
+ * context, and this guard verifies the checkable fact — the builder verbs
+ * exist — before the value is admitted at its TYPED face. The type-level
+ * judgments (domain-equal joins, boundness, the recursion cut) live in the
+ * interfaces themselves; the runtime twin of every one of them is a
+ * construction-time validation in this module.
+ */
+function isTypedScope(scope) {
+    return typeof scope.match === "function";
+}
+/** Builds one query-rule builder (the typed face of the raw builder). */
+function makeQueryRuleScope(classes) {
+    const raw = makeRawScope({ kind: "query", classes });
+    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 });
+    if (!isTypedScope(raw)) {
+        throw errors.new("program output rule builder construction incomplete");
     }
-    const rules = built.rules.map(function freezeRule(rule, index) {
-        assertNegationSafety(`query construction (rule ${index})`, rule);
-        return Object.freeze([...rule]);
+    return raw;
+}
+/** Renders one head column's signature for the rule-alignment check. */
+function headSignature(column) {
+    const entry = column.entry;
+    if (entry.kind === "var" || entry.kind === "measure") {
+        return `${column.name}:var`;
+    }
+    const agg = entry.agg;
+    if (agg.op === "fold") {
+        return `${column.name}:${agg.fold}`;
+    }
+    if (agg.op === "arg") {
+        return `${column.name}:${agg.direction}`;
+    }
+    return `${column.name}:${agg.op}`;
+}
+/**
+ * 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 must keep one shape.
+ */
+function paramRegistryOf(recs, rules) {
+    const order = [];
+    const byName = new Map();
+    function fold(uses) {
+        for (const use of uses) {
+            const existing = byName.get(use.name);
+            if (existing === undefined) {
+                order.push(use.name);
+                byName.set(use.name, { shape: use.shape, anchor: use.anchor, op: use.op });
+                continue;
+            }
+            if (existing.shape !== use.shape) {
+                throw errors.new(`query param ${use.name} is used both as a ${existing.shape} param and a ${use.shape} param — one name, one shape`);
+            }
+            if (existing.anchor === undefined && use.anchor !== undefined) {
+                existing.anchor = use.anchor;
+                existing.op = use.op;
+            }
+        }
+    }
+    for (const rec of recs) {
+        for (const rule of rec.rules) {
+            fold(rule.paramUses);
+        }
+    }
+    for (const rule of rules) {
+        fold(rule.paramUses);
+    }
+    return Object.freeze(order.map(function entryOf(name) {
+        const entry = byName.get(name);
+        if (entry === undefined) {
+            throw errors.new(`query param ${name} lost its registry entry`);
+        }
+        return Object.freeze({ name, shape: entry.shape, anchor: entry.anchor, op: entry.op });
+    }));
+}
+/**
+ * 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 by
+ * construction), and the param registry folds in program-walk order.
+ */
+function makeRawQuery(theory, recs, rules) {
+    const first = rules[0];
+    if (first === undefined) {
+        throw errors.new("a query needs at least one rule");
+    }
+    const signature = first.select.map(headSignature).join(", ");
+    rules.forEach(function verifyHead(rule, index) {
+        const candidate = rule.select.map(headSignature).join(", ");
+        if (candidate !== signature) {
+            throw errors.new(`every rule of a query derives the same head — rule 0 selects (${signature}), rule ${index} selects (${candidate})`);
+        }
     });
-    Object.freeze(registry.params);
-    Object.freeze(registry.predicates);
-    Object.freeze(registry);
-    return Object.freeze({
-        schema: theory,
-        data: Object.freeze({ registry, rules: Object.freeze(rules), select: Object.freeze(select) })
+    const data = Object.freeze({
+        recs: Object.freeze([...recs]),
+        rules: Object.freeze([...rules]),
+        select: first.select,
+        params: paramRegistryOf(recs, rules)
     });
+    const value = {
+        schema: theory,
+        data,
+        rule(build) {
+            const built = build(makeRawScope({ kind: "query", classes: theory.classes }));
+            return makeRawQuery(theory, recs, [...rules, built.rule]);
+        }
+    };
+    Object.freeze(value);
+    return value;
+}
+/**
+ * The query values' trusted admission seam (the `refsComplete` 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;
+}
+/** 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");
+    }
+    return raw;
+}
+/**
+ * Opens a query over a schema: `query(S).rule(r => ...)`. Each `.rule`
+ * adds one conjunctive rule; multiple rules are the set union (answers are
+ * SETS — no order or limit exists anywhere; hosts sort). The schema's
+ * law-computed class map rides into every rule builder — the join walls
+ * compare class names off it, at the type level and at construction alike.
+ */
+function query(theory) {
+    const start = {
+        rule(build) {
+            const built = build(makeQueryRuleScope(theory.classes));
+            return makeQuery(theory, [], [built.rule]);
+        }
+    };
+    Object.freeze(start);
+    return start;
 }
 /** The typed shape refusal of the literal tagger — a genuine failure, never data. */
 function literalShapeError(context, expected, value) {
@@ -165,20 +726,54 @@ function isIntervalShaped(value) {
         typeof value.start === "bigint" &&
         typeof value.end === "bigint");
 }
+/**
+ * Tags one closed-reference literal: the bare handle id, verified against
+ * the roster (the belt the type level cannot provide — structural values
+ * make any bigint spellable here) and tagged u64 — queries cross ids,
+ * never handle names.
+ */
+function taggedHandleId(context, closed, value) {
+    if (typeof value !== "bigint") {
+        throw literalShapeError(context, `a ${closed.name} handle id (bigint)`, value);
+    }
+    if (closed.handles[Number(value)] === undefined) {
+        throw errors.new(`${context}: closed relation ${closed.name} has no handle with id ${value} (roster holds ${closed.handles.length})`);
+    }
+    return { kind: "u64", value };
+}
+/**
+ * Tags one literal in an interval element domain: a bigint tags as the
+ * element (the membership typing rule's point side), an interval-shaped
+ * value as the interval (value equality).
+ */
+function taggedAtElementDomain(context, element, value) {
+    if (typeof value === "bigint") {
+        if (element === "u64") {
+            return { kind: "u64", value };
+        }
+        return { kind: "i64", value };
+    }
+    if (isIntervalShaped(value)) {
+        if (element === "u64") {
+            return { kind: "intervalU64", start: value.start, end: value.end };
+        }
+        return { kind: "intervalI64", start: value.start, end: value.end };
+    }
+    throw literalShapeError(context, "bigint (point) or { start, end } (interval)", value);
+}
 /**
  * Tags one host literal at a FIELD position (atom bindings): the field's
- * structural type directs the tag, never a guess. At an interval field a
+ * structural kind directs the tag, never a guess. At an interval field a
  * bigint literal tags as the ELEMENT type — the IR's membership typing
  * rule (point membership), an interval-shaped literal as the interval
- * (value equality). A closed-reference literal is its branded id, tagged
- * u64 after a roster re-verification (queries cross ids, never handle
- * names).
+ * (value equality). A closed-reference literal is its bare handle id,
+ * tagged u64 after a roster verification.
  */
 function taggedLiteral(context, field, value) {
-    if (field.closed !== undefined) {
+    if ("closed" in field) {
         return taggedHandleId(context, field.closed, value);
     }
-    switch (field.type.kind) {
+    switch (field.kind) {
         case "bool": {
             if (typeof value !== "boolean") {
                 throw literalShapeError(context, "boolean", value);
@@ -197,68 +792,34 @@ function taggedLiteral(context, field, value) {
             }
             return { kind: "i64", value };
         }
-        case "string": {
+        case "str": {
             if (typeof value !== "string") {
                 throw literalShapeError(context, "string", value);
             }
             return { kind: "string", value };
         }
-        case "fixedBytes": {
+        case "bytes": {
             if (!(value instanceof Uint8Array)) {
                 throw literalShapeError(context, "Uint8Array", value);
             }
             return { kind: "fixedBytes", value };
         }
         case "interval":
-            return taggedAtElementDomain(context, field.type.element, value);
+            return taggedAtElementDomain(context, field.element, value);
     }
 }
 /**
- * Tags one closed-reference literal: the branded id, re-verified against
- * the roster (the belt the type level cannot provide against forged
- * brands) and tagged u64 — queries cross ids, never handle names.
- */
-function taggedHandleId(context, closed, value) {
-    if (typeof value !== "bigint") {
-        throw literalShapeError(context, `a ${closed.name} handle id (bigint)`, value);
-    }
-    if (closed.handles[Number(value)] === undefined) {
-        throw errors.new(`${context}: closed relation ${closed.name} has no handle with id ${value} (roster holds ${closed.handles.length})`);
-    }
-    return { kind: "u64", value };
-}
-/**
- * Tags one literal in an interval element domain: a bigint tags as the
- * element (the membership typing rule's point side), an interval-shaped
- * value as the interval (value equality).
- */
-function taggedAtElementDomain(context, element, value) {
-    if (typeof value === "bigint") {
-        if (element === "u64") {
-            return { kind: "u64", value };
-        }
-        return { kind: "i64", value };
-    }
-    if (isIntervalShaped(value)) {
-        if (element === "u64") {
-            return { kind: "intervalU64", start: value.start, end: value.end };
-        }
-        return { kind: "intervalI64", start: value.start, end: value.end };
-    }
-    throw literalShapeError(context, "bigint (point) or { start, end } (interval)", value);
-}
-/**
- * Tags one host literal at a COMPARISON position, where no field position
- * directs the type: the sibling term's element domain does — a measure
- * sibling is u64, an interval-field sibling contributes its element type
- * (so both a point literal in `covers` and a `span` literal in `allen`
- * tag correctly), a scalar sibling its own type. At `pointIn` the operand
- * order is interval-left, point-right (`ir::CmpOp::PointIn`), so an
- * interval-shaped literal beside a scalar element-typed sibling is the
- * LEGAL lhs of `covers(span(...), t)` and tags as the interval of the
- * sibling's element domain; under every other operator an interval shape
- * against a scalar sibling stays refused (the engine's IllegalComparison
- * — eq/lt interval-vs-scalar is not a comparison).
+ * Tags one host literal at a COMPARISON or PARAM position, where the
+ * SIBLING anchors the type: a measure sibling is u64, an interval-field
+ * sibling contributes its element domain (so both a point literal in
+ * `covers` and a `span` literal in `allen` tag correctly), a scalar
+ * sibling its own type. At `pointIn` the operand order is interval-left,
+ * point-right (`ir::CmpOp::PointIn`), so an interval-shaped literal
+ * beside a scalar element-typed sibling is the LEGAL lhs of
+ * `covers(span(...), t)` and tags as the interval of the sibling's
+ * element domain; under every other operator an interval shape against a
+ * scalar sibling stays refused (the engine's IllegalComparison — the
+ * bug-hunt fix, preserved op-aware).
  */
 function taggedCmpLiteral(context, sibling, value, op) {
     if (sibling === "measure") {
@@ -267,195 +828,161 @@ function taggedCmpLiteral(context, sibling, value, op) {
         }
         return { kind: "u64", value };
     }
-    if (sibling.type.kind === "interval") {
-        return taggedAtElementDomain(context, sibling.type.element, value);
+    if (!("closed" in sibling) && sibling.kind === "interval") {
+        return taggedAtElementDomain(context, sibling.element, value);
     }
-    if (op === "pointIn" && (sibling.type.kind === "u64" || sibling.type.kind === "i64") && isIntervalShaped(value)) {
-        return taggedAtElementDomain(context, sibling.type.kind, value);
+    if (op === "pointIn" &&
+        !("closed" in sibling) &&
+        (sibling.kind === "u64" || sibling.kind === "i64") &&
+        isIntervalShaped(value)) {
+        return taggedAtElementDomain(context, sibling.kind, value);
     }
     return taggedLiteral(context, sibling, value);
 }
 /** Creates one rule-scoped variable numberer. */
-function makeVarIds(registry) {
+function makeVarIds() {
     const assigned = new Map();
-    const state = { next: 0 };
     return {
-        of(variable) {
-            const existing = assigned.get(variable);
+        of(name) {
+            const existing = assigned.get(name);
             if (existing !== undefined) {
                 return existing;
             }
-            if (!registry.vars.has(variable)) {
-                throw errors.new(`query lowering: the variable declared from ${variable.relation}.${variable.field} belongs to a different query scope`);
-            }
-            const id = state.next;
-            state.next += 1;
-            assigned.set(variable, id);
-            return id;
-        },
-        synthetic() {
-            const id = state.next;
-            state.next += 1;
+            const id = assigned.size;
+            assigned.set(name, id);
             return id;
         }
     };
 }
-/** Resolves a param term to its dense positional id, recording the use. */
-function paramIdOf(ctx, value, name) {
-    const index = ctx.registry.paramIndex.get(value);
-    if (index === undefined) {
-        throw errors.new(`query lowering: param ${name} belongs to a different query scope`);
+/** Resolves a param name to its dense positional id. */
+function paramIdOf(ctx, name) {
+    const id = ctx.paramIds.get(name);
+    if (id === undefined) {
+        throw errors.new(`query lowering: param ${name} is not in the query's registry`);
     }
-    ctx.usedParams.add(index);
-    return index;
-}
-/** Lowers one atom (either polarity) and appends any `oneOf` disjunctions. */
-function lowerAtom(ctx, atom, ids, extraConditions) {
-    const source = lowerSource(ctx, atom.source);
-    const bindings = atom.bindings.map(function lowerBinding(binding) {
-        return [
-            fieldOrdinal(atom.source, binding),
-            lowerBindingTerm(ctx, atom.source, binding, ids, extraConditions)
-        ];
-    });
-    return { source, bindings };
+    return id;
 }
-/** Lowers an atom source to its numeric id, verifying scope membership. */
-function lowerSource(ctx, source) {
-    if (source.kind === "relation") {
-        const member = ctx.theory.relations[source.relation.name];
-        if (member !== source.relation) {
-            throw errors.new(`query lowering: relation ${source.relation.name} is not the relation value schema ${ctx.theory.name} declares`);
-        }
-        const id = ctx.relationIds.get(source.relation.name);
-        if (id === undefined) {
-            throw errors.new(`query lowering: relation ${source.relation.name} has no ordinal`);
-        }
-        return { kind: "edb", relation: id };
+/**
+ * Lowers one EDB atom (either polarity). A CLOSED owner lowers through the
+ * same edb source — its ordinal is its record-declaration slot exactly like
+ * an ordinary relation's — with field ordinals over the SEALED shape: `id`
+ * at 0, each payload column at its declared index + 1 (`matchFieldsOf`
+ * carries the shift; the lowering golden pins it).
+ */
+function lowerAtom(ctx, atom, ids) {
+    const member = ctx.theory.relations[atom.relation.name];
+    if (member !== atom.relation) {
+        throw errors.new(`query lowering: relation ${atom.relation.name} is not the relation value schema ${ctx.theory.name} declares`);
     }
-    const pred = ctx.predicateIds.get(source.pred);
-    if (pred === undefined) {
-        throw errors.new(`query lowering: predicate ${source.pred.name} was declared in a different query scope`);
+    const relationId = ctx.relationIds.get(atom.relation.name);
+    if (relationId === undefined) {
+        throw errors.new(`query lowering: relation ${atom.relation.name} has no ordinal`);
     }
-    return { kind: "idb", pred };
-}
-/** A binding's field ordinal: declaration index (relations) or head position (predicates). */
-function fieldOrdinal(source, binding) {
-    if (source.kind === "relation") {
-        const ordinal = source.relation.data.fields.findIndex(function byName(candidate) {
+    const ordered = matchFieldsOf(atom.relation);
+    const bindings = atom.bindings.map(function lowerBinding(binding) {
+        const ordinal = ordered.findIndex(function byName(candidate) {
             return candidate.name === binding.field;
         });
         if (ordinal < 0) {
-            throw errors.new(`query lowering: relation ${source.relation.name} has no field ${binding.field}`);
+            throw errors.new(`query lowering: relation ${atom.relation.name} has no field ${binding.field}`);
         }
-        return ordinal;
-    }
-    const ordinal = source.pred.columns.findIndex(function byName(candidate) {
-        return candidate.name === binding.field;
+        return [ordinal, lowerBindingTerm(ctx, `${atom.relation.name}.${binding.field}`, binding, ids)];
     });
-    if (ordinal < 0) {
-        throw errors.new(`query lowering: predicate ${source.pred.name} has no column ${binding.field}`);
-    }
-    return ordinal;
+    return { source: { kind: "edb", relation: relationId }, bindings };
 }
-/** Lowers one binding term; an `oneOf` mints a fresh variable + disjunction. */
-function lowerBindingTerm(ctx, source, binding, ids, extraConditions) {
-    const context = `${sourceName(source)}.${binding.field}`;
+/** Lowers one binding term. */
+function lowerBindingTerm(ctx, context, binding, ids) {
     const bound = binding.term;
-    if (bound.kind === "term") {
-        const value = bound.value;
-        switch (value[term]) {
-            case "var":
-                return { kind: "var", var: ids.of(value) };
-            case "param":
-                return { kind: "param", param: paramIdOf(ctx, value, value.name) };
-            case "paramSet":
-                return { kind: "paramSet", param: paramIdOf(ctx, value, value.name) };
-            case "maskParam":
-                throw errors.new(`${context}: an Allen-mask param is not a field-typed binding`);
-        }
-    }
-    if (bound.kind === "oneOf") {
-        const minted = ids.synthetic();
-        const leaves = bound.values.map(function equalityLeaf(candidate) {
-            return {
-                kind: "leaf",
-                cmp: {
-                    op: { kind: "eq" },
-                    lhs: { kind: "var", var: minted },
-                    rhs: { kind: "literal", value: taggedLiteral(context, binding.data, candidate) }
-                }
-            };
-        });
-        extraConditions.push({ kind: "or", children: leaves });
-        return { kind: "var", var: minted };
+    switch (bound.kind) {
+        case "var":
+            return { kind: "var", var: ids.of(bound.name) };
+        case "param":
+            return { kind: "param", param: paramIdOf(ctx, bound.name) };
+        case "setParam":
+            return { kind: "paramSet", param: paramIdOf(ctx, bound.name) };
+        case "literal":
+            return { kind: "literal", value: taggedLiteral(context, binding.data, bound.value) };
     }
-    return { kind: "literal", value: taggedLiteral(context, binding.data, bound.value) };
 }
-/** Lowers one comparison side; literals tag by the sibling's element domain (op-aware at `pointIn`). */
-function lowerCmpTerm(ctx, side, sibling, ids, op) {
-    if (side.kind === "term") {
-        const value = side.value;
-        switch (value[term]) {
-            case "var":
-                return { kind: "var", var: ids.of(value) };
-            case "param":
-                return { kind: "param", param: paramIdOf(ctx, value, value.name) };
-            case "paramSet":
-                return { kind: "paramSet", param: paramIdOf(ctx, value, value.name) };
-            case "maskParam":
-                throw errors.new("query lowering: an Allen-mask param is not a comparison term — masks live in allen()'s mask position");
-        }
+/** Lowers one idb atom: positional head bindings, `FieldId(i)` = head position i. */
+function lowerIdbAtom(ctx, rec, vars, ids) {
+    const pred = ctx.recIds.get(rec);
+    if (pred === undefined) {
+        throw errors.new(`query lowering: rec ${rec.name} was declared by a different program`);
     }
-    if (side.kind === "measure") {
-        return { kind: "measure", var: ids.of(side.over) };
+    const arity = rec.rules[0]?.select.length;
+    if (arity !== undefined && vars.length !== arity) {
+        throw errors.new(`query lowering: idb ${rec.name} takes ${arity} positions, got ${vars.length}`);
     }
-    if (sibling.kind === "term") {
-        const value = sibling.value;
-        if (value[term] === "maskParam") {
-            throw errors.new("query lowering: an Allen-mask param cannot type a literal side");
+    const bindings = vars.map(function lowerPosition(name, position) {
+        return [position, { kind: "var", var: ids.of(name) }];
+    });
+    return { source: { kind: "idb", pred }, bindings };
+}
+/** Lowers one comparison side; literals tag by the sibling's anchor (op-aware at `pointIn`). */
+function lowerCmpTerm(ctx, rule, side, sibling, ids, op) {
+    switch (side.kind) {
+        case "var":
+            return { kind: "var", var: ids.of(side.name) };
+        case "param":
+            return { kind: "param", param: paramIdOf(ctx, side.name) };
+        case "setParam":
+            return { kind: "paramSet", param: paramIdOf(ctx, side.name) };
+        case "measure":
+            return { kind: "measure", var: ids.of(side.name) };
+        case "literal": {
+            const anchor = cmpAnchorOf(ctx, rule, sibling);
+            if (anchor === undefined) {
+                throw errors.new("query lowering: a comparison literal needs a bound-variable, measure, or anchored-param sibling to type it");
+            }
+            return { kind: "literal", value: taggedCmpLiteral("comparison literal", anchor, side.value, op) };
         }
-        return {
-            kind: "literal",
-            value: taggedCmpLiteral("comparison literal", value.data, side.value, op)
-        };
+    }
+}
+/** Resolves the anchor a comparison literal tags by: the sibling's field, the measure, or an anchored param. */
+function cmpAnchorOf(ctx, rule, sibling) {
+    if (sibling.kind === "var") {
+        return rule.varFields[sibling.name]?.field;
     }
     if (sibling.kind === "measure") {
-        return {
-            kind: "literal",
-            value: taggedCmpLiteral("comparison literal", "measure", side.value, op)
-        };
+        return "measure";
     }
-    throw errors.new("query lowering: a comparison without a variable or parameter side is constant-valued");
+    if (sibling.kind === "param" || sibling.kind === "setParam") {
+        return ctx.params.get(sibling.name)?.anchor;
+    }
+    return undefined;
 }
 /** Lowers one comparison. */
-function lowerComparison(ctx, cmp, ids) {
-    const op = cmp.op;
-    if (op.kind === "allen") {
-        const mask = op.mask.kind === "literal"
-            ? { kind: "literal", mask: op.mask.mask }
-            : { kind: "param", param: paramIdOf(ctx, op.mask.param, op.mask.param.name) };
+function lowerComparison(ctx, rule, 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) };
         return {
             op: { kind: "allen", mask },
-            lhs: lowerCmpTerm(ctx, cmp.lhs, cmp.rhs, ids, "allen"),
-            rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, "allen")
+            lhs: lowerCmpTerm(ctx, rule, cmp.lhs, cmp.rhs, ids, "allen"),
+            rhs: lowerCmpTerm(ctx, rule, cmp.rhs, cmp.lhs, ids, "allen")
         };
     }
     return {
-        op: { kind: op.kind },
-        lhs: lowerCmpTerm(ctx, cmp.lhs, cmp.rhs, ids, op.kind),
-        rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, op.kind)
+        op: { kind: cmp.op },
+        lhs: lowerCmpTerm(ctx, rule, cmp.lhs, cmp.rhs, ids, cmp.op),
+        rhs: lowerCmpTerm(ctx, rule, cmp.rhs, cmp.lhs, ids, cmp.op)
     };
 }
 /** Lowers one condition node (comparison leaf or and/or tree). */
-function lowerCondition(ctx, condition, ids) {
-    if (condition.item === "cmp") {
-        return { kind: "leaf", cmp: lowerComparison(ctx, condition, ids) };
+function lowerCondition(ctx, rule, cond, ids) {
+    if (cond.kind === "cmp") {
+        return { kind: "leaf", cmp: lowerComparison(ctx, rule, cond, ids) };
     }
     return {
-        kind: condition.op,
-        children: condition.children.map(function lowerChild(child) {
-            return lowerCondition(ctx, child, ids);
+        kind: cond.op,
+        children: cond.children.map(function lowerChild(child) {
+            return lowerCondition(ctx, rule, child, ids);
         })
     };
 }
@@ -467,40 +994,35 @@ function lowerFind(entry, ids) {
     if (entry.kind === "measure") {
         return { kind: "measure", var: ids.of(entry.over) };
     }
-    const aggregate = entry.aggregate;
-    switch (aggregate.op) {
+    const agg = entry.agg;
+    switch (agg.op) {
         case "count":
             return { kind: "aggregate", op: { kind: "count" } };
         case "countDistinct":
-            return { kind: "aggregate", op: { kind: "countDistinct" }, over: ids.of(aggregate.over) };
+            return { kind: "aggregate", op: { kind: "countDistinct" }, over: ids.of(agg.over) };
         case "fold": {
-            const over = aggregate.over;
-            if (isTerm(over)) {
-                return { kind: "aggregate", op: { kind: aggregate.fold }, over: ids.of(over) };
+            if (typeof agg.over === "string") {
+                return { kind: "aggregate", op: { kind: agg.fold }, over: ids.of(agg.over) };
             }
-            return { kind: "aggregateMeasure", op: { kind: aggregate.fold }, over: ids.of(over.measure) };
+            return { kind: "aggregateMeasure", op: { kind: agg.fold }, over: ids.of(agg.over.duration) };
         }
         case "arg":
-            return {
-                kind: "aggregate",
-                op: { kind: aggregate.direction, key: ids.of(aggregate.key) },
-                over: ids.of(aggregate.over)
-            };
+            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(aggregate.over) };
+            return { kind: "aggregate", op: { kind: "pack" }, over: ids.of(agg.over) };
     }
 }
 /** One aggregate's var-free head-op kind (`AggOp::head_op`). */
-function headOpOf(aggregate) {
-    switch (aggregate.op) {
+function headOpOf(agg) {
+    switch (agg.op) {
         case "count":
             return "count";
         case "countDistinct":
             return "countDistinct";
         case "fold":
-            return aggregate.fold;
+            return agg.fold;
         case "arg":
-            return aggregate.direction;
+            return agg.direction;
         case "pack":
             return "pack";
     }
@@ -511,42 +1033,51 @@ function headTermOf(column) {
     if (entry.kind === "var" || entry.kind === "measure") {
         return { kind: "var" };
     }
-    return { kind: "aggregate", op: headOpOf(entry.aggregate) };
+    return { kind: "aggregate", op: headOpOf(entry.agg) };
 }
-/** Lowers one rule: body walked in written order, finds supplied per shape. */
-function lowerRule(ctx, body, finds) {
-    const ids = makeVarIds(ctx.registry);
+/** Lowers one rule: body walked in written order (var ids by first occurrence), finds last. */
+function lowerRule(ctx, rule) {
+    const ids = makeVarIds();
     const atoms = [];
     const negated = [];
     const conditions = [];
-    const extraConditions = [];
-    for (const item of body) {
-        if (item.item === "atom") {
-            const lowered = lowerAtom(ctx, item, ids, extraConditions);
-            if (item.negated) {
-                negated.push(lowered);
+    for (const item of rule.items) {
+        switch (item.kind) {
+            case "atom": {
+                atoms.push(lowerAtom(ctx, item.atom, ids));
+                break;
             }
-            else {
-                atoms.push(lowered);
+            case "negated": {
+                negated.push(lowerAtom(ctx, item.atom, ids));
+                break;
+            }
+            case "idb": {
+                atoms.push(lowerIdbAtom(ctx, item.rec, item.vars, ids));
+                break;
+            }
+            case "cond": {
+                conditions.push(lowerCondition(ctx, rule, item.cond, ids));
+                break;
             }
-            continue;
         }
-        conditions.push(lowerCondition(ctx, item, ids));
     }
     return {
-        finds: finds(ids),
+        finds: rule.select.map(function findOf(column) {
+            return lowerFind(column.entry, ids);
+        }),
         atoms,
         negated,
-        conditions: [...conditions, ...extraConditions]
+        conditions
     };
 }
 /**
  * Lowers a query value to the bridge's `ProgramIr` — pure and stable: the
- * declared predicates in declaration order (`PredId` = index), the output
- * predicate (built from `rules` + `select`) appended last. Relations lower
- * by declaration ordinal, the law the engine's own manifest pins;
- * `db.prepare` re-verifies the alignment against the live manifest before
- * sending.
+ * recs in declaration order (`PredId` = index), the output predicate
+ * (rules + head) appended last. Relations lower by declaration ordinal,
+ * the law the engine's own manifest pins; `db.prepare` re-verifies the
+ * alignment against the live manifest before sending. Every registered
+ * param must carry a field anchor by now — an unanchorable param (its
+ * every use beside a literal) is refused here, naming it.
  */
 function lowerQuery(q) {
     const theory = q.schema;
@@ -554,51 +1085,39 @@ function lowerQuery(q) {
     Object.keys(theory.relations).forEach(function assignOrdinal(name, index) {
         relationIds.set(name, index);
     });
-    const registry = q.data.registry;
-    const predicateIds = new Map();
-    registry.predicates.forEach(function assignPredId(pred, index) {
-        predicateIds.set(pred, index);
+    const recIds = new Map();
+    q.data.recs.forEach(function assignPredId(rec, index) {
+        recIds.set(rec, index);
+    });
+    const paramIds = new Map();
+    const params = new Map();
+    q.data.params.forEach(function assignParamId(entry, index) {
+        if (entry.anchor === undefined && entry.shape !== "mask") {
+            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, predicateIds, registry, usedParams: new Set() };
-    const predicates = registry.predicates.map(function lowerPredicate(pred) {
+    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: pred.columns.map(function boundHead() {
-                return { kind: "var" };
-            }),
-            rules: pred.rules.map(function lowerClause(rule) {
-                return lowerRule(ctx, rule.body, function clauseFinds(ids) {
-                    return rule.finds.map(function findVar(variable) {
-                        return { kind: "var", var: ids.of(variable) };
-                    });
-                });
+            head: head.select.map(headTermOf),
+            rules: rec.rules.map(function lowerRecRule(rule) {
+                return lowerRule(ctx, rule);
             })
         };
     });
     predicates.push({
         head: q.data.select.map(headTermOf),
-        rules: q.data.rules.map(function lowerOutputRule(body) {
-            return lowerRule(ctx, body, function outputFinds(ids) {
-                return q.data.select.map(function findOf(column) {
-                    return lowerFind(column.entry, ids);
-                });
-            });
+        rules: q.data.rules.map(function lowerOutputRule(rule) {
+            return lowerRule(ctx, rule);
         })
     });
-    /**
-     * The dead-declaration refusal: a declared param no rule reached is
-     * unexecutable BOTH ways — its inferred `Params` contribution is nothing
-     * (params ride item phantoms), yet the wire marshal is the full registry
-     * in declaration order, while the ENGINE's arity is usage-derived. The
-     * contradiction is refused here, the earliest seam that knows usage, so
-     * every query that lowers has registry == used set (and the dense-id
-     * hole a skipped middle declaration would open never exists).
-     */
-    registry.params.forEach(function assertUsed(entry, index) {
-        if (!ctx.usedParams.has(index)) {
-            throw errors.new(`query declares param ${entry.name} but no rule uses it — remove the declaration or reference it`);
-        }
-    });
-    return { predicates, output: registry.predicates.length };
+    return { predicates, output: q.data.recs.length };
 }
-export { lowerQuery, query, taggedLiteral };
+export { lowerQuery, makeOutputRuleScope, makeQuery, makeRawScope, query, taggedCmpLiteral, taggedLiteral };
 //# sourceMappingURL=lower.js.map