@bjornpagen/bumbledb 0.15.0 → 0.17.0

package/dist/query/lower.js

@@ -1,47 +1,13 @@
-/**
- * `query()` and the IR lowering, REFERENCE-IDENTITY edition. A query is
- * built kysely-shaped — variables minted by {@link v} outside the rule and
- * reused by REFERENCE to join:
- *
- *   query(S).rule((r) => {
- *     const acct = v(Account)
- *     const h = v(Holder)
- *     return r
- *       .match(Account, { id: acct.id, holder: acct.holder })
- *       .match(Holder, { id: acct.holder })
- *       .where(r.eq(acct.holder, r.param("root")))
- *       .find({ account: acct.id, holder: acct.holder })
- *   })
- *
- * — and is an INERT value: `Query<Rels, Row, Params>` with `Row` inferred
- * from each rule's `.find` RECORD (its keys ARE the answer columns) and
- * `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,
- * 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
- * STABLE — the same query value lowers to deeply-equal IR every time, and
- * 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 (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 { 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. */
+import { fieldJoins, inferred, isTerm, makeParam, makeSetParam, renderFieldKind, term } from "#query/scope.ts";
 const termOps = Object.freeze({
     param: makeParam,
     inSet: makeSetParam,
-    duration: makeDuration,
     eq,
     ne,
     lt,
@@ -59,7 +25,6 @@ const termOps = Object.freeze({
     max,
     pack
 });
-/** The empty rule state. */
 const EMPTY_RULE = Object.freeze({
     items: Object.freeze([]),
     bound: new Set(),
@@ -80,11 +45,6 @@ function mintSlotOf(context, ref) {
     }
     return { field: ref.field, class: context.classes[ref.owner.name]?.[ref.column] };
 }
-/**
- * Judges one membership ARRAY at a binding position — legal exactly at a
- * CLOSED-reference field, holding ≥ 2 DISTINCT handle names. The returned
- * name is CONTENT-ADDRESSED (vocabulary + the member SET).
- */
 function membershipSet(context, field, value) {
     const roster = rosterOf(field);
     if (roster === undefined) {
@@ -110,14 +70,6 @@ function membershipSet(context, field, value) {
     const key = [...members].sort();
     return { name: `∈ ${roster.name} ${JSON.stringify(key)}`, members: Object.freeze(members) };
 }
-/**
- * Resolves a bindings record against an atom owner's matchable fields, in
- * the record's written order: terms classify by their runtime tag,
- * everything else is a bare literal. Every VARIABLE binding judges
- * `fieldJoins(mintSlot, positionSlot)` and throws on a class-unequal reuse
- * (the runtime twin of `CheckBindings`); the bound refs are collected for
- * the rule's boundness set.
- */
 function resolveBindings(context, label, relation, bindings) {
     const entries = [];
     const vars = [];
@@ -171,8 +123,6 @@ function resolveBindings(context, label, relation, bindings) {
                     }));
                     break;
                 }
-                case "duration":
-                    throw errors.new(`${label}.${fieldName}: the measure is not a field-typed value — it lives in comparisons and find entries`);
             }
         }
         else if (Array.isArray(value)) {
@@ -193,7 +143,6 @@ function resolveBindings(context, label, relation, bindings) {
     }
     return { atom: Object.freeze({ relation, bindings: Object.freeze(entries) }), vars, uses };
 }
-/** Extends a rule state with one positive atom; the bound variable references accumulate into the boundness set. */
 function advanceMatch(context, state, relation, bindings) {
     const resolved = resolveBindings(context, `relation ${relation.name}`, relation, bindings);
     const bound = new Set(state.bound);
@@ -206,7 +155,6 @@ function advanceMatch(context, state, relation, bindings) {
         paramUses: Object.freeze([...state.paramUses, ...resolved.uses])
     });
 }
-/** Resolves one comparison side to its runtime term (variables and the measure ride by reference). */
 function cmpTermDataOf(value) {
     if (isTerm(value)) {
         switch (value[term]) {
@@ -216,31 +164,15 @@ function cmpTermDataOf(value) {
                 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", ref: value.over });
         }
     }
     return Object.freeze({ kind: "literal", value });
 }
-/**
- * One comparison side's contribution to the param census: a param/set side
- * anchors to its SIBLING — a variable's field descriptor or the measure; an
- * unanchorable use records with no anchor.
- */
 function sideUses(op, side, sibling, uses) {
     if (side.kind !== "param" && side.kind !== "setParam") {
         return;
     }
-    let anchor;
-    if (sibling.kind === "var") {
-        anchor = sibling.ref.field;
-    }
-    else if (sibling.kind === "measure") {
-        anchor = "measure";
-    }
-    else {
-        anchor = undefined;
-    }
+    const anchor = sibling.kind === "var" ? sibling.ref.field : undefined;
     uses.push(Object.freeze({
         name: side.name,
         shape: side.kind === "param" ? "value" : "set",
@@ -249,7 +181,6 @@ function sideUses(op, side, sibling, uses) {
         members: undefined
     }));
 }
-/** Lowers one condition VALUE to its runtime data, recording param uses. */
 function condDataOf(cond, uses) {
     if (cond.cond === "cmp") {
         const lhs = cmpTermDataOf(cond.lhs);
@@ -278,7 +209,6 @@ function condDataOf(cond, uses) {
     }
     throw errors.new("a negated atom is not a condition-tree node — pass not(...) to where() directly, never inside and()/or()");
 }
-/** Extends a rule state with one `.where` item (a condition or a negated atom). */
 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");
@@ -309,15 +239,6 @@ function advanceWhere(context, state, cond) {
         paramUses: Object.freeze([...state.paramUses, ...uses])
     });
 }
-/**
- * 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
- * interior-only identity projection of a finished table is spellable with no
- * re-grounding join. A NEGATED one binds nothing, only rejects.
- */
 function advanceInterior(state, target, bindings, kind) {
     const resolved = [];
     for (const [key, value] of Object.entries(bindings)) {
@@ -341,7 +262,6 @@ function advanceInterior(state, target, bindings, kind) {
         paramUses: state.paramUses
     });
 }
-/** Narrows a find entry to an aggregate value. */
 function isAggregateEntry(value) {
     return typeof value === "object" && value !== null && "agg" in value;
 }
@@ -352,7 +272,6 @@ function asVarTerm(context, value) {
     }
     throw errors.new(`${context}: expected a variable`);
 }
-/** Classifies one aggregate find entry into its runtime data (variables ride by reference). */
 function aggDataOf(name, entry) {
     if (entry.agg === "count") {
         return Object.freeze({ op: "count" });
@@ -365,10 +284,7 @@ function aggDataOf(name, entry) {
             if (isTerm(over) && over[term] === "var") {
                 return Object.freeze({ op: "fold", fold: entry.agg, over });
             }
-            if (isTerm(over) && over[term] === "duration") {
-                return Object.freeze({ op: "fold", fold: entry.agg, over: Object.freeze({ duration: over.over }) });
-            }
-            throw errors.new(`find ${name} (${entry.agg}): takes a variable or r.duration(v)`);
+            throw errors.new(`find ${name} (${entry.agg}): takes a variable`);
         }
         case "pack":
             return Object.freeze({ op: "pack", over: asVarTerm(`find ${name} (pack)`, over) });
@@ -376,11 +292,6 @@ function aggDataOf(name, entry) {
             throw errors.new(`find ${name}: unknown aggregate ${entry.agg}`);
     }
 }
-/**
- * Classifies one find entry into its named answer column (the KEY names the
- * column, `count` included). The `slot`/`closed` slices are resolved LATER,
- * at rule completion, where boundness and the mint slots are in hand.
- */
 function findColumnOf(name, entry) {
     if (isTerm(entry)) {
         if (entry[term] === "var") {
@@ -391,15 +302,7 @@ function findColumnOf(name, entry) {
                 slot: undefined
             });
         }
-        if (entry[term] === "duration") {
-            return Object.freeze({
-                name,
-                entry: Object.freeze({ kind: "measure", over: entry.over }),
-                closed: undefined,
-                slot: undefined
-            });
-        }
-        throw errors.new(`find ${name}: a ${entry[term]} is not projectable — find takes variables, r.duration(v), or aggregates`);
+        throw errors.new(`find ${name}: a ${entry[term]} is not projectable — find takes variables or aggregates`);
     }
     if (isAggregateEntry(entry)) {
         return Object.freeze({
@@ -409,43 +312,39 @@ function findColumnOf(name, entry) {
             slot: undefined
         });
     }
-    throw errors.new(`find ${name}: not a find entry — find takes variables, r.duration(v), or aggregates`);
+    throw errors.new(`find ${name}: not a find entry — find takes variables or aggregates`);
 }
 /**
- * The orderable ban's pointed refusal (`docs/architecture/10-data-model.md`
+ * The orderable ban's pointed refusal
  * § orderability): a closed reference is equality-and-membership only.
  */
 function closedOrderError(context, position, vocabulary) {
-    return errors.new(`${context}: ${position} is a ${vocabulary} reference — declaration order is an accident, not semantics: vocabularies do not order (docs/architecture/10-data-model.md; equality, membership, and counting remain)`);
+    return errors.new(`${context}: ${position} is a ${vocabulary} reference — declaration order is an accident, not semantics: vocabularies do not order (equality, membership, and counting remain)`);
 }
-/** The comparison ops under the orderable ban (order roster + point membership). */
 function isOrderOp(op) {
     return op === "lt" || op === "le" || op === "gt" || op === "ge" || op === "pointIn";
 }
-/** Requires a variable to be bound by a relation atom of the rule (the boundness wall — invisible to the type tier). */
 function assertBound(where, bound, ref) {
     if (!bound.has(ref)) {
         throw errors.new(`${where}: the variable ${ref.label} is not bound by a relation atom of the rule`);
     }
 }
-/** Requires a variable to be interval-typed (the measure's and pack's domain), off its own descriptor. */
 function assertInterval(where, ref) {
     if (ref.field.kind !== "interval") {
         throw errors.new(`${where}: ${ref.label} is not interval-typed — the measure is defined over interval-typed variables only`);
     }
 }
-/** Requires a variable's own field to be non-closed (the orderable ban's runtime twin). */
 function assertNotClosed(where, position, ref) {
     const roster = rosterOf(ref.field);
     if (roster !== undefined) {
         throw closedOrderError(where, `${position} ${ref.label}`, roster.name);
     }
 }
-/**
- * The classed mint slot one answer column's VALUES flow from: a projected
- * variable's mint slot. Counts, folds, `pack` and the measure derive
- * numbers/intervals, so they resolve no slot.
- */
+function assertNumeric(where, position, ref) {
+    if (ref.field.kind !== "u64" && ref.field.kind !== "i64") {
+        throw errors.new(`${where}: ${position} ${ref.label} is ${ref.field.kind}, not numeric — a fold reads u64/i64 only`);
+    }
+}
 function findColumnSlotOf(context, column) {
     const entry = column.entry;
     if (entry.kind === "var") {
@@ -453,7 +352,6 @@ function findColumnSlotOf(context, column) {
     }
     return undefined;
 }
-/** Validates one find column's variable references (boundness + the orderable/interval walls, off the var's own field). */
 function validateColumn(context, bound, column) {
     const where = `${contextLabel(context)} find ${column.name}`;
     const entry = column.entry;
@@ -461,23 +359,14 @@ function validateColumn(context, bound, column) {
         assertBound(where, bound, entry.over);
         return;
     }
-    if (entry.kind === "measure") {
-        assertBound(where, bound, entry.over);
-        assertInterval(where, entry.over);
-        return;
-    }
     const agg = entry.agg;
     switch (agg.op) {
         case "count":
             return;
         case "fold": {
-            if ("duration" in agg.over) {
-                assertBound(where, bound, agg.over.duration);
-                assertInterval(where, agg.over.duration);
-                return;
-            }
             assertBound(where, bound, agg.over);
             assertNotClosed(where, `the ${agg.fold} input`, agg.over);
+            assertNumeric(where, `the ${agg.fold} input`, agg.over);
             return;
         }
         case "pack":
@@ -486,11 +375,6 @@ function validateColumn(context, bound, column) {
             return;
     }
 }
-/**
- * Validates one condition's variable references against the rule's bound
- * set — and, for `eq`/`ne` over two variables, holds the class wall through
- * the mint slots (the unification IS a join; bare pairs only with bare).
- */
 function validateCond(context, bound, cond) {
     const label = contextLabel(context);
     if (cond.kind === "cmp") {
@@ -502,10 +386,6 @@ function validateCond(context, bound, cond) {
                     throw closedOrderError(label, `the ${cond.op.kind} side ${side.ref.label}`, roster.name);
                 }
             }
-            if (side.kind === "measure") {
-                assertBound(label, bound, side.ref);
-                assertInterval(label, side.ref);
-            }
         }
         if ((cond.op.kind === "eq" || cond.op.kind === "ne") && cond.lhs.kind === "var" && cond.rhs.kind === "var") {
             assertBound(label, bound, cond.lhs.ref);
@@ -522,16 +402,6 @@ function validateCond(context, bound, cond) {
         validateCond(context, bound, child);
     }
 }
-/**
- * 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 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 table's own first rule is in flight
- * (`finds` empty), the completing rule's OWN find columns ARE the head.
- */
 function validateInterior(context, bound, item, columns) {
     const label = contextLabel(context);
     const headColumns = item.target.finds.length > 0 ? item.target.finds : columns;
@@ -567,12 +437,6 @@ function validateInterior(context, bound, item, columns) {
         }
     }
 }
-/**
- * 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, interior
- * head pairing, and condition validation.
- */
 function completeRule(context, state, rawColumns) {
     const label = contextLabel(context);
     if (rawColumns.length === 0) {
@@ -601,11 +465,9 @@ function completeRule(context, state, rawColumns) {
     }
     return Object.freeze({ items: state.items, finds: Object.freeze(columns), 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":
@@ -618,11 +480,9 @@ function contextLabel(context) {
             return `rec ${context.self.name} rec`;
     }
 }
-/** RecHandle is name-only staging; RecHead/RecData carry the sealed finds. */
 function isRecHead(rec) {
     return Array.isArray(rec.finds);
 }
-/** 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;
@@ -648,22 +508,15 @@ function lookupDerived(context, name) {
     }
     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-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 notInteriorAdvance(context, state, name, bindings) {
     if (context.kind === "rec-base" || context.kind === "rec-arm") {
         throw errors.new(`rec ${context.self.name}: a rec 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`);
     }
     return advanceInterior(state, lookupDerived(context, name), bindings, "negatedInterior");
 }
-/** 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";
@@ -679,7 +532,6 @@ function findColumns(context, entries) {
     }
     return columns;
 }
-/** Builds one runtime chain (immutably — every step is a fresh chain over fresh state). */
 function makeRawChain(context, state) {
     const chain = {
         match(relation, bindings) {
@@ -698,7 +550,6 @@ function makeRawChain(context, state) {
     Object.freeze(chain);
     return chain;
 }
-/** Builds one runtime rule-builder over a context. */
 function makeRawScope(context) {
     const scope = {
         ...termOps,
@@ -724,7 +575,6 @@ function makeRawScope(context) {
 function isTypedScope(scope) {
     return typeof scope.match === "function";
 }
-/** Builds one query-rule builder (the typed face of the raw builder). */
 function makeQueryRuleScope(theory, env) {
     const raw = makeRawScope({ kind: "query", classes: theory.classes, theory, ...env });
     if (!isTypedScope(raw)) {
@@ -732,7 +582,6 @@ function makeQueryRuleScope(theory, env) {
     }
     return raw;
 }
-/** Builds one interior-rule builder. */
 function makeInteriorRuleScope(theory, env, self) {
     const raw = makeRawScope({ kind: "interior", self, classes: theory.classes, theory, ...env });
     if (!isTypedScope(raw)) {
@@ -761,14 +610,12 @@ function makeRecRuleScope(theory, env, self, kind) {
     }
     return raw;
 }
-/** Renders one head column's closed slice for the rule-alignment check's diagnostics. */
 function renderClosedSlice(closed) {
     return closed === undefined ? "a bare value" : `a ${closed.name} reference`;
 }
-/** 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") {
+    if (entry.kind === "var") {
         return `${column.name}:var`;
     }
     const agg = entry.agg;
@@ -777,11 +624,6 @@ function headSignature(column) {
     }
     return `${column.name}:${agg.op}`;
 }
-/** The roster a param anchor carries: present exactly on a closed-reference field anchor. */
-function anchorRosterOf(anchor) {
-    return anchor === "measure" ? undefined : rosterOf(anchor);
-}
-/** Renders one param anchor's closedness for the registry's coherence diagnostics. */
 function renderParamAnchor(roster) {
     return roster === undefined ? "a non-closed position" : `a ${roster.name} reference`;
 }
@@ -820,8 +662,8 @@ function paramRegistryOf(interiors, rec, rules) {
                 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) {
-                const registered = anchorRosterOf(existing.anchor);
-                const anchored = anchorRosterOf(use.anchor);
+                const registered = rosterOf(existing.anchor);
+                const anchored = rosterOf(use.anchor);
                 if (registered !== anchored) {
                     throw errors.new(`query param ${use.name} is anchored at ${renderParamAnchor(registered)} and at ${renderParamAnchor(anchored)} — a closed-anchored param translates handle names through ONE roster (one name, one domain); name the params differently`);
                 }
@@ -853,14 +695,6 @@ function paramRegistryOf(interiors, rec, rules) {
         if (entry === undefined) {
             throw errors.new(`query param ${name} lost its registry entry`);
         }
-        /**
-         * A membership array's handle names are program constants, so the
-         * entry stores the resolved IMAGE: each name rides the one
-         * roster-verification point (`taggedHandleId`, through
-         * `taggedCmpLiteral`) exactly once, HERE — an out-of-roster name
-         * fails at build, and every execute returns this frozen value by
-         * reference.
-         */
         let membership;
         if (entry.members !== undefined) {
             const anchor = entry.anchor;
@@ -877,7 +711,6 @@ function paramRegistryOf(interiors, rec, rules) {
         return Object.freeze({ name, shape: entry.shape, anchor: entry.anchor, op: entry.op, membership });
     }));
 }
-/** 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) {
@@ -906,13 +739,6 @@ function assertAlignedHeads(label, rules) {
 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. CQ lowering does not mention rec;
- * Reach carries RecData by value.
- */
 function makeRawQuery(theory, interiors, rec, rules) {
     assertAlignedHeads("a query", rules);
     const first = rules[0];
@@ -959,7 +785,6 @@ function makeRawQuery(theory, interiors, rec, rules) {
 function makeQuery(theory, interiors, rec, rules) {
     return makeRawQuery(theory, interiors, rec, rules);
 }
-/** 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`);
@@ -974,7 +799,6 @@ function collectInterior(theory, env, name, builds) {
     }
     return Object.freeze({ name, finds: first.finds, rules: Object.freeze(rules) });
 }
-/** Collects the Rec from tagged base/rec builder arrays. */
 function collectRec(theory, interiors, name, baseBuilds, recBuilds) {
     if (baseBuilds.length === 0) {
         throw errors.new(`query: rec ${name} has no base arms`);
@@ -1017,7 +841,6 @@ function collectRec(theory, interiors, name, baseBuilds, recBuilds) {
     });
     return recData;
 }
-/** Builds the CQ query start (interiors, then reach or the first main rule). */
 function makeQueryStart(theory, interiors) {
     const env = { interiors };
     const start = {
@@ -1053,7 +876,6 @@ function makeQueryStart(theory, interiors) {
     Object.freeze(start);
     return start;
 }
-/** Builds the Reach query start (rec sealed; only the first main rule remains). */
 function makeQueryReachStart(theory, interiors, rec) {
     const env = { interiors, rec };
     const start = {
@@ -1065,21 +887,9 @@ function makeQueryReachStart(theory, interiors, rec) {
     Object.freeze(start);
     return start;
 }
-/**
- * Opens a query over a schema: `query(S).rule(r => ...)`, optionally with
- * `interior` / `reach` 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, []);
 }
-/**
- * Tags one closed-reference literal: the handle NAME, verified against the
- * roster and translated to its declaration-order row id, tagged u64. THE
- * single roster-verification point of the query surface.
- */
 function taggedHandleId(context, closed, value) {
     if (typeof value !== "string") {
         throw literalShapeError(context, `a ${closed.name} handle name (string)`, value);
@@ -1090,11 +900,6 @@ function taggedHandleId(context, closed, value) {
     }
     return { kind: "u64", value: BigInt(id) };
 }
-/**
- * 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") {
@@ -1110,10 +915,6 @@ function taggedAtElementDomain(context, element, value) {
     }
     throw literalShapeError(context, "bigint (point) or { start, end } (interval)", value);
 }
-/**
- * Tags one host literal at a FIELD position (atom bindings): the field's
- * structural kind directs the tag, never a guess.
- */
 function taggedLiteral(context, field, value) {
     const roster = rosterOf(field);
     if (roster !== undefined) {
@@ -1167,12 +968,6 @@ function taggedLiteral(context, field, value) {
  * interval shape against a scalar sibling stays refused.
  */
 function taggedCmpLiteral(context, sibling, value, op) {
-    if (sibling === "measure") {
-        if (typeof value !== "bigint") {
-            throw literalShapeError(context, "bigint (the measure is u64)", value);
-        }
-        return { kind: "u64", value };
-    }
     if (rosterOf(sibling) === undefined && sibling.kind === "interval") {
         return taggedAtElementDomain(context, sibling.element, value);
     }
@@ -1184,7 +979,6 @@ function taggedCmpLiteral(context, sibling, value, op) {
     }
     return taggedLiteral(context, sibling, value);
 }
-/** Creates one rule-scoped variable numberer. */
 function freshVarIds() {
     const assigned = new Map();
     return {
@@ -1199,7 +993,6 @@ function freshVarIds() {
         }
     };
 }
-/** Resolves a param name to its dense positional id. */
 function paramIdOf(ctx, name) {
     const id = ctx.paramIds.get(name);
     if (id === undefined) {
@@ -1207,10 +1000,6 @@ function paramIdOf(ctx, name) {
     }
     return id;
 }
-/**
- * Lowers one EDB atom (either polarity). A CLOSED owner lowers through the
- * same edb source, with field ordinals over the SEALED shape.
- */
 function lowerAtom(ctx, atom, ids) {
     const member = ctx.theory.relations[atom.relation.name];
     if (member !== atom.relation) {
@@ -1232,7 +1021,6 @@ function lowerAtom(ctx, atom, ids) {
     });
     return { source: { kind: "edb", relation: relationId }, bindings };
 }
-/** Lowers one binding term. A membership ARRAY lowers to the existing param-set term over its content-addressed entry. */
 function lowerBindingTerm(ctx, context, binding, ids) {
     const bound = binding.term;
     switch (bound.kind) {
@@ -1273,7 +1061,6 @@ function lowerInteriorAtom(ctx, target, bindings, ids) {
     });
     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) {
     switch (side.kind) {
         case "var":
@@ -1282,31 +1069,24 @@ function lowerCmpTerm(ctx, side, sibling, ids, op) {
             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.ref) };
         case "literal": {
             const anchor = cmpAnchorOf(ctx, sibling);
             if (anchor === undefined) {
-                throw errors.new("query lowering: a comparison literal needs a bound-variable, measure, or anchored-param sibling to type it");
+                throw errors.new("query lowering: a comparison literal needs a bound-variable or anchored-param sibling to type it");
             }
             return { kind: "literal", value: taggedCmpLiteral("comparison literal", anchor, side.value, op) };
         }
     }
 }
-/** Resolves the anchor a comparison literal tags by: the sibling variable's field, the measure, or an anchored param. */
 function cmpAnchorOf(ctx, sibling) {
     if (sibling.kind === "var") {
         return sibling.ref.field;
     }
-    if (sibling.kind === "measure") {
-        return "measure";
-    }
     if (sibling.kind === "param" || sibling.kind === "setParam") {
         return ctx.params.get(sibling.name)?.anchor;
     }
     return undefined;
 }
-/** Lowers one comparison. */
 function lowerComparison(ctx, cmp, ids) {
     if (cmp.op.kind === "allen") {
         return {
@@ -1321,7 +1101,6 @@ function lowerComparison(ctx, cmp, ids) {
         rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, cmp.op.kind)
     };
 }
-/** Lowers one condition node (comparison leaf or and/or tree). */
 function lowerCondition(ctx, cond, ids) {
     if (cond.kind === "cmp") {
         return { kind: "leaf", cmp: lowerComparison(ctx, cond, ids) };
@@ -1333,29 +1112,20 @@ function lowerCondition(ctx, cond, ids) {
         })
     };
 }
-/** Lowers one find entry to its per-rule find term. */
 function lowerFind(entry, ids) {
     if (entry.kind === "var") {
         return { kind: "var", var: ids.of(entry.over) };
     }
-    if (entry.kind === "measure") {
-        return { kind: "measure", var: ids.of(entry.over) };
-    }
     const agg = entry.agg;
     switch (agg.op) {
         case "count":
             return { kind: "count" };
-        case "fold": {
-            if ("duration" in agg.over) {
-                return { kind: "aggregateMeasure", op: { kind: agg.fold }, over: ids.of(agg.over.duration) };
-            }
+        case "fold":
             return { kind: "aggregate", op: { kind: agg.fold }, over: ids.of(agg.over) };
-        }
         case "pack":
             return { kind: "pack", over: ids.of(agg.over) };
     }
 }
-/** One aggregate's var-free head-op kind (`AggOp::head_op`). */
 function headOpOf(agg) {
     switch (agg.op) {
         case "count":
@@ -1366,15 +1136,13 @@ function headOpOf(agg) {
             return "pack";
     }
 }
-/** One find entry's var-free head shape. */
 function headTermOf(column) {
     const entry = column.entry;
-    if (entry.kind === "var" || entry.kind === "measure") {
+    if (entry.kind === "var") {
         return { kind: "var" };
     }
     return { kind: "aggregate", op: headOpOf(entry.agg) };
 }
-/** Lowers one rule: body walked in written order (var ids by first occurrence), finds last. */
 function lowerRule(ctx, rule) {
     const ids = freshVarIds();
     const atoms = [];
@@ -1413,11 +1181,6 @@ function lowerRule(ctx, rule) {
         conditions
     };
 }
-/**
- * Lowers a query value to the bridge's `QueryIr` — pure and stable:
- * interiors in declaration order, then CQ or Reach, then main. Every
- * registered param must carry a field anchor by now.
- */
 function lowerQuery(q) {
     const theory = q.schema;
     const relationIds = new Map();