@bjornpagen/bumbledb 0.20.2 → 1.0.0

package/dist/query/lower.js

@@ -1,10 +1,13 @@
-import * as errors from "@superbuilders/errors";
 import { sealedFieldsOf } from "#closed.ts";
-import { assertDeclarationOrderKey, isIntervalValue, literalShapeError, rosterOf } from "#fields.ts";
+import { AuthoringError, SdkInvariantError } from "#errors.ts";
+import { assertDeclarationOrderKey, f64 as f64Field, isFloatIntervalValue, isIntervalValue, literalShapeError, rosterOf, u64 as u64Field } 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 { computeFieldOf, computeVarsOf, isComputeExpr, MAX_COMPUTE_DEPTH } from "#query/compute.ts";
+import { count, max, mean, min, pack, sum } from "#query/find.ts";
 import { parseQueryIr } from "#query/parse-ir.ts";
-import { fieldAntiJoins, fieldJoins, headFieldJoins, inferred, isTerm, makeParam, makeSetParam, renderFieldKind, term } from "#query/scope.ts";
+import { fieldAntiJoins, fieldJoins, headFieldJoins, importFacadeOf, importFacadeOfOwner, inferred, isImportedSource, isTerm, labelImport, makeParam, makeSetParam, renderFieldKind, term } from "#query/scope.ts";
+import { literalWireOf } from "#scalar.ts";
+import { Uuid } from "#uuid.ts";
 const termOps = Object.freeze({
     param: makeParam,
     inSet: makeSetParam,
@@ -21,6 +24,7 @@ const termOps = Object.freeze({
     not,
     count,
     sum,
+    mean,
     min,
     max,
     pack
@@ -40,21 +44,42 @@ const EMPTY_RULE = Object.freeze({
  * cross-binding joins mutually class-equal by transitivity.
  */
 function mintSlotOf(context, ref) {
+    const facade = importFacadeOfOwner(ref.owner);
+    if (facade !== undefined) {
+        // An import var's mint slot is the imported head column's slot:
+        // the descriptor it projected and the carrier class that survived
+        // the projection (aggregate outputs are bare derived scalars).
+        const column = facade.columns.get(ref.column);
+        if (column === undefined || facade.source.schema !== context.theory) {
+            throw new AuthoringError({
+                message: `the variable ${ref.label} was minted from a query template schema ${context.theory.name} does not own`
+            });
+        }
+        return column.slot ?? { field: ref.field, class: undefined };
+    }
     if (context.theory.relations[ref.owner.name] !== ref.owner) {
-        throw errors.new(`the variable ${ref.label} was minted from a relation schema ${context.theory.name} does not declare — mint variables with v() from the schema's own relations`);
+        throw new AuthoringError({
+            message: `the variable ${ref.label} was minted from a relation schema ${context.theory.name} does not declare — mint variables with v() from the schema's own relations`
+        });
     }
     return { field: ref.field, class: context.classes[ref.owner.name]?.[ref.column] };
 }
 function membershipSet(context, field, value) {
     const roster = rosterOf(field);
     if (roster === undefined) {
-        throw errors.new(`${context}: a membership array is the closed-reference spelling — ordinary field membership is a bound ∈-set param (r.inSet)`);
+        throw new AuthoringError({
+            message: `${context}: a membership array is the closed-reference spelling — ordinary field membership is a bound ∈-set param (r.inSet)`
+        });
     }
     if (value.length === 0) {
-        throw errors.new(`${context}: an empty membership array selects nothing — write the query you mean`);
+        throw new AuthoringError({
+            message: `${context}: an empty membership array selects nothing — write the query you mean`
+        });
     }
     if (value.length === 1) {
-        throw errors.new(`${context}: a one-element membership array is the bare literal respelled — write the literal (the canonical-utterance law: one meaning, one spelling)`);
+        throw new AuthoringError({
+            message: `${context}: a one-element membership array is the bare literal respelled — write the literal (the canonical-utterance law: one meaning, one spelling)`
+        });
     }
     const seen = new Set();
     const members = value.map(function memberName(member) {
@@ -62,7 +87,9 @@ function membershipSet(context, field, value) {
             throw literalShapeError(context, `a ${roster.name} handle name (string)`, member);
         }
         if (seen.has(member)) {
-            throw errors.new(`${context}: the membership array spells ${member} twice — write it once (the canonical-utterance law: one meaning, one spelling)`);
+            throw new AuthoringError({
+                message: `${context}: the membership array spells ${member} twice — write it once (the canonical-utterance law: one meaning, one spelling)`
+            });
         }
         seen.add(member);
         return member;
@@ -84,7 +111,7 @@ function resolveBindings(context, label, relation, bindings, joins = fieldJoins)
             return candidate.name === fieldName;
         });
         if (declared === undefined) {
-            throw errors.new(`${label} has no field ${fieldName}`);
+            throw new AuthoringError({ message: `${label} has no field ${fieldName}` });
         }
         const fieldClass = relationClasses?.[fieldName];
         let bound;
@@ -95,7 +122,9 @@ function resolveBindings(context, label, relation, bindings, joins = fieldJoins)
                     const mint = mintSlotOf(context, ref);
                     const positionSlot = { field: declared.field, class: fieldClass };
                     if (!joins(mint, positionSlot)) {
-                        throw errors.new(`${label}: the variable ${ref.label} joins domain-unequal fields — minted at ${renderFieldKind(mint)}, reused at ${renderFieldKind(positionSlot)} (a var joins only class-equal slots; bare pairs only with bare)`);
+                        throw new AuthoringError({
+                            message: `${label}: the variable ${ref.label} joins domain-unequal fields — minted at ${renderFieldKind(mint)}, reused at ${renderFieldKind(positionSlot)} (a var joins only class-equal slots; bare pairs only with bare)`
+                        });
                     }
                     bound = Object.freeze({ kind: "var", ref });
                     vars.push(ref);
@@ -190,7 +219,9 @@ function condDataOf(cond, uses) {
         if (cond.op === "allen") {
             const maskValue = cond.mask;
             if (typeof maskValue !== "number") {
-                throw errors.new("allen: the mask position takes a 13-bit mask number built from the ALLEN constants");
+                throw new AuthoringError({
+                    message: "allen: the mask position takes a 13-bit mask number built from the ALLEN constants"
+                });
             }
             return Object.freeze({
                 kind: "cmp",
@@ -207,11 +238,13 @@ function condDataOf(cond, uses) {
         });
         return Object.freeze({ kind: "tree", op: cond.op, children: Object.freeze(children) });
     }
-    throw errors.new("a negated atom is not a condition-tree node — pass not(...) to where() directly, never inside and()/or()");
+    throw new AuthoringError({
+        message: "a negated atom is not a condition-tree node — pass not(...) to where() directly, never inside and()/or()"
+    });
 }
 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");
+        throw new AuthoringError({ message: "where() takes a comparison, an and()/or() tree, or a negated atom" });
     }
     if (cond.cond === "notInterior") {
         const bindings = Object.fromEntries(Object.entries(cond.bindings ?? {}).filter(function defined([, value]) {
@@ -246,7 +279,9 @@ function advanceInterior(state, target, bindings, kind) {
             continue;
         }
         if (!isTerm(value) || value[term] !== "var") {
-            throw errors.new(`interior ${target.name}: position ${key} takes a variable — bind literals and params through where()/match()`);
+            throw new AuthoringError({
+                message: `interior ${target.name}: position ${key} takes a variable — bind literals and params through where()/match()`
+            });
         }
         resolved.push(Object.freeze({ key, ref: value }));
     }
@@ -270,7 +305,7 @@ function asVarTerm(context, value) {
     if (isTerm(value) && value[term] === "var") {
         return value;
     }
-    throw errors.new(`${context}: expected a variable`);
+    throw new AuthoringError({ message: `${context}: expected a variable` });
 }
 function aggDataOf(name, entry) {
     if (entry.agg === "count") {
@@ -279,17 +314,18 @@ function aggDataOf(name, entry) {
     const over = entry.over;
     switch (entry.agg) {
         case "sum":
+        case "mean":
         case "min":
         case "max": {
             if (isTerm(over) && over[term] === "var") {
                 return Object.freeze({ op: "fold", fold: entry.agg, over });
             }
-            throw errors.new(`find ${name} (${entry.agg}): takes a variable`);
+            throw new AuthoringError({ message: `find ${name} (${entry.agg}): takes a variable` });
         }
         case "pack":
             return Object.freeze({ op: "pack", over: asVarTerm(`find ${name} (pack)`, over) });
         default:
-            throw errors.new(`find ${name}: unknown aggregate ${entry.agg}`);
+            throw new AuthoringError({ message: `find ${name}: unknown aggregate ${entry.agg}` });
     }
 }
 function findColumnOf(name, entry) {
@@ -302,7 +338,17 @@ function findColumnOf(name, entry) {
                 slot: undefined
             });
         }
-        throw errors.new(`find ${name}: a ${entry[term]} is not projectable — find takes variables or aggregates`);
+        throw new AuthoringError({
+            message: `find ${name}: a ${entry[term]} is not projectable — find takes variables, aggregates or Compute expressions`
+        });
+    }
+    if (isComputeExpr(entry)) {
+        return Object.freeze({
+            name,
+            entry: Object.freeze({ kind: "compute", expr: entry, result: entry.result }),
+            closed: undefined,
+            slot: undefined
+        });
     }
     if (isAggregateEntry(entry)) {
         return Object.freeze({
@@ -312,26 +358,34 @@ function findColumnOf(name, entry) {
             slot: undefined
         });
     }
-    throw errors.new(`find ${name}: not a find entry — find takes variables or aggregates`);
+    throw new AuthoringError({
+        message: `find ${name}: not a find entry — find takes variables, aggregates or Compute expressions`
+    });
 }
 /**
  * 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 (equality, membership, and counting remain)`);
+    return new AuthoringError({
+        message: `${context}: ${position} is a ${vocabulary} reference — declaration order is an accident, not semantics: vocabularies do not order (equality, membership, and counting remain)`
+    });
 }
 function isOrderOp(op) {
     return op === "lt" || op === "le" || op === "gt" || op === "ge" || op === "pointIn";
 }
 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`);
+        throw new AuthoringError({
+            message: `${where}: the variable ${ref.label} is not bound by a relation atom of the rule`
+        });
     }
 }
 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`);
+        throw new AuthoringError({
+            message: `${where}: ${ref.label} is not interval-typed — the measure is defined over interval-typed variables only`
+        });
     }
 }
 function assertNotClosed(where, position, ref) {
@@ -341,16 +395,40 @@ function assertNotClosed(where, position, ref) {
     }
 }
 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`);
+    if (ref.field.kind !== "u64" && ref.field.kind !== "i64" && ref.field.kind !== "f64") {
+        throw new AuthoringError({
+            message: `${where}: ${position} ${ref.label} is ${ref.field.kind}, not numeric — a fold reads u64/i64/f64 only`
+        });
     }
 }
+/**
+ * The head column's slot: a projected variable keeps its mint slot; an
+ * aggregate output is a NEW derived scalar — its descriptor follows the
+ * aggregate's typing (count is u64, mean is f64, sum/min/max keep the
+ * input's scalar kind, pack keeps the interval kind) and its class is
+ * BARE: a derived value is not the carrier the class law tracked.
+ */
 function findColumnSlotOf(context, column) {
     const entry = column.entry;
     if (entry.kind === "var") {
         return mintSlotOf(context, entry.over);
     }
-    return undefined;
+    if (entry.kind === "compute") {
+        return { field: computeFieldOf(entry.result), class: undefined };
+    }
+    const agg = entry.agg;
+    switch (agg.op) {
+        case "count":
+            return { field: u64Field, class: undefined };
+        case "fold": {
+            if (agg.fold === "mean") {
+                return { field: f64Field, class: undefined };
+            }
+            return { field: agg.over.field, class: undefined };
+        }
+        case "pack":
+            return { field: agg.over.field, class: undefined };
+    }
 }
 function validateColumn(context, bound, column) {
     const where = `${contextLabel(context)} find ${column.name}`;
@@ -359,6 +437,15 @@ function validateColumn(context, bound, column) {
         assertBound(where, bound, entry.over);
         return;
     }
+    if (entry.kind === "compute") {
+        // Kind agreement, closed-reference and depth walls hold at
+        // construction (#query/compute.ts); boundness is a RULE property,
+        // judged here like every other term position.
+        for (const ref of computeVarsOf(entry.expr)) {
+            assertBound(where, bound, ref);
+        }
+        return;
+    }
     const agg = entry.agg;
     switch (agg.op) {
         case "count":
@@ -367,6 +454,9 @@ function validateColumn(context, bound, column) {
             assertBound(where, bound, agg.over);
             assertNotClosed(where, `the ${agg.fold} input`, agg.over);
             assertNumeric(where, `the ${agg.fold} input`, agg.over);
+            if (agg.fold === "mean" && agg.over.field.kind !== "f64") {
+                throw new AuthoringError({ message: `${where}: mean requires an f64 input; cast integers explicitly` });
+            }
             return;
         }
         case "pack":
@@ -393,7 +483,9 @@ function validateCond(context, bound, cond) {
             const lhs = mintSlotOf(context, cond.lhs.ref);
             const rhs = mintSlotOf(context, cond.rhs.ref);
             if (!fieldJoins(lhs, rhs)) {
-                throw errors.new(`${label}: ${cond.op.kind}(${cond.lhs.ref.label}, ${cond.rhs.ref.label}) unifies domain-unequal fields — ${cond.lhs.ref.label} bound at ${renderFieldKind(lhs)}, ${cond.rhs.ref.label} at ${renderFieldKind(rhs)} (a var joins only class-equal slots; bare pairs only with bare)`);
+                throw new AuthoringError({
+                    message: `${label}: ${cond.op.kind}(${cond.lhs.ref.label}, ${cond.rhs.ref.label}) unifies domain-unequal fields — ${cond.lhs.ref.label} bound at ${renderFieldKind(lhs)}, ${cond.rhs.ref.label} at ${renderFieldKind(rhs)} (a var joins only class-equal slots; bare pairs only with bare)`
+                });
             }
         }
         return;
@@ -413,17 +505,23 @@ function validateInterior(context, bound, item, columns) {
     });
     for (const key of keys) {
         if (!headNames.includes(key)) {
-            throw errors.new(`${label}: interior ${item.target.name} binds ${key}, not a head column of ${item.target.name} (head columns: ${headNames.join(", ")})`);
+            throw new AuthoringError({
+                message: `${label}: interior ${item.target.name} binds ${key}, not a head column of ${item.target.name} (head columns: ${headNames.join(", ")})`
+            });
         }
     }
     for (const name of headNames) {
         if (!keys.includes(name)) {
-            throw errors.new(`${label}: interior ${item.target.name} omits the head column ${name} — an interior join binds every head column of ${item.target.name}`);
+            throw new AuthoringError({
+                message: `${label}: interior ${item.target.name} omits the head column ${name} — an interior join binds every head column of ${item.target.name}`
+            });
         }
     }
     for (const binding of item.bindings) {
         if (item.kind === "negatedInterior" && !bound.has(binding.ref)) {
-            throw errors.new(`${label}: negated interior ${item.target.name} names the variable ${binding.ref.label}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`);
+            throw new AuthoringError({
+                message: `${label}: negated interior ${item.target.name} names the variable ${binding.ref.label}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`
+            });
         }
         const headColumn = headColumns.find(function byName(column) {
             return column.name === binding.key;
@@ -433,14 +531,16 @@ function validateInterior(context, bound, item, columns) {
         }
         const mint = mintSlotOf(context, binding.ref);
         if (!fieldJoins(headColumn.slot, mint)) {
-            throw errors.new(`${label}: interior ${item.target.name} joins the variable ${binding.ref.label} (${renderFieldKind(mint)}) at head column ${binding.key} (${renderFieldKind(headColumn.slot)}) — a var joins only class-equal slots; bare pairs only with bare`);
+            throw new AuthoringError({
+                message: `${label}: interior ${item.target.name} joins the variable ${binding.ref.label} (${renderFieldKind(mint)}) at head column ${binding.key} (${renderFieldKind(headColumn.slot)}) — a var joins only class-equal slots; bare pairs only with bare`
+            });
         }
     }
 }
 function completeRule(context, state, rawColumns) {
     const label = contextLabel(context);
     if (rawColumns.length === 0) {
-        throw errors.new(`${label}: a find needs at least one entry`);
+        throw new AuthoringError({ message: `${label}: a find needs at least one entry` });
     }
     const columns = rawColumns.map(function enrichColumn(column) {
         assertDeclarationOrderKey(`${label} find column`, column.name);
@@ -452,7 +552,9 @@ function completeRule(context, state, rawColumns) {
         if (item.kind === "negated") {
             for (const binding of item.atom.bindings) {
                 if (binding.term.kind === "var" && !state.bound.has(binding.term.ref)) {
-                    throw errors.new(`${label}: negated ${item.atom.relation.name} atom binds the variable ${binding.term.ref.label} at position ${binding.field}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`);
+                    throw new AuthoringError({
+                        message: `${label}: negated ${item.atom.relation.name} atom binds the variable ${binding.term.ref.label} at position ${binding.field}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`
+                    });
                 }
             }
         }
@@ -489,44 +591,177 @@ function lookupDerived(context, name) {
     });
     if (interior !== undefined) {
         if (context.kind === "interior" && name === context.self) {
-            throw errors.new(`interior ${name}: an interior does not read itself — declaration order is topological (a self-read is InteriorNotPrior)`);
+            throw new AuthoringError({
+                message: `interior ${name}: an interior does not read itself — declaration order is topological (a self-read is InteriorNotPrior)`
+            });
         }
         return interior;
     }
     const rec = "rec" in context ? context.rec : undefined;
     if (rec !== undefined && rec.name === name) {
         if (context.kind === "interior") {
-            throw errors.new(`interior ${context.self}: interiors cannot read the rec — this cut's interiors are a prefix`);
+            throw new AuthoringError({
+                message: `interior ${context.self}: interiors cannot read the rec — this cut's interiors are a prefix`
+            });
         }
         if (context.kind === "rec-base") {
-            throw errors.new(`rec ${rec.name}: a base arm does not read the rec — self-atoms belong on rec arms`);
+            throw new AuthoringError({
+                message: `rec ${rec.name}: a base arm does not read the rec — self-atoms belong on rec arms`
+            });
         }
         if (!isRecHead(rec)) {
-            throw errors.new(`rec ${rec.name}: rec arms resolve the rec head after base arms seal it`);
+            throw new AuthoringError({ message: `rec ${rec.name}: rec arms resolve the rec head after base arms seal it` });
         }
         return rec;
     }
-    throw errors.new(`${contextLabel(context)}: no derived table named ${name} is in scope`);
+    throw new AuthoringError({ message: `${contextLabel(context)}: no derived table named ${name} is in scope` });
 }
 function interiorAdvance(context, state, name, bindings) {
     return advanceInterior(state, lookupDerived(context, name), bindings, "interior");
 }
+const importEntries = new WeakMap();
+const importTables = new WeakSet();
+function importEntryOf(context, imported) {
+    const cached = importEntries.get(imported);
+    if (cached !== undefined) {
+        if (imported.schema !== context.theory) {
+            throw new AuthoringError({
+                message: `${contextLabel(context)}: the imported query belongs to schema ${imported.schema.name}, not ${context.theory.name} — templates compose within one schema`
+            });
+        }
+        return cached;
+    }
+    if (imported.schema !== context.theory) {
+        throw new AuthoringError({
+            message: `${contextLabel(context)}: the imported query belongs to schema ${imported.schema.name}, not ${context.theory.name} — templates compose within one schema`
+        });
+    }
+    if (imported.data.kind === "reach") {
+        throw new AuthoringError({
+            message: `${contextLabel(context)}: a recursive query is not importable as a relation expression yet — declare the recursion on the consuming query (C05 boundary, recorded)`
+        });
+    }
+    const userParams = imported.data.params.filter(function userSupplied(entry) {
+        return entry.membership === undefined;
+    });
+    if (userParams.length > 0) {
+        throw new AuthoringError({
+            message: `${contextLabel(context)}: the imported query takes parameters (${userParams
+                .map((entry) => entry.name)
+                .join(", ")}) — bind an import's meaning at declaration; parameterized imports are not supported`
+        });
+    }
+    const facade = importFacadeOf(imported);
+    const table = Object.freeze({
+        name: facade.owner.name,
+        finds: imported.data.finds,
+        rules: imported.data.rules
+    });
+    const entry = Object.freeze({ table, inner: imported.data.interiors });
+    importEntries.set(imported, entry);
+    importTables.add(table);
+    importInner.set(table, entry.inner);
+    return entry;
+}
+const importInner = new WeakMap();
+/**
+ * Every import table the assembled query references, in first-reference
+ * order (declared interiors first, then rec arms, then main rules — the
+ * lowering walk), deduplicated by table identity.
+ */
+function referencedImports(interiors, rec, rules) {
+    const seen = new Set();
+    const out = [];
+    function walk(ruleList) {
+        for (const rule of ruleList) {
+            for (const item of rule.items) {
+                if (item.kind !== "interior" && item.kind !== "negatedInterior") {
+                    continue;
+                }
+                const target = item.target;
+                if (importTables.has(target) && !seen.has(target)) {
+                    seen.add(target);
+                    out.push(target);
+                }
+            }
+        }
+    }
+    for (const interior of interiors) {
+        walk(interior.rules);
+    }
+    if (rec !== undefined) {
+        walk(rec.base);
+        walk(rec.rec);
+    }
+    walk(rules);
+    return out;
+}
+/**
+ * Splices referenced imports ahead of the declared interiors: each import's
+ * inner interiors first (its rules read them), then the import's own table.
+ * Interior prior-ness is preserved — declared interiors never read imports
+ * they could not have named, and main/rec rules may read anything earlier.
+ * Duplicate names across the final roster refuse.
+ */
+function spliceImports(interiors, rec, rules) {
+    const imports = referencedImports(interiors, rec, rules);
+    if (imports.length === 0) {
+        return interiors;
+    }
+    const spliced = [];
+    const names = new Set();
+    const added = new Set();
+    function add(table) {
+        if (added.has(table)) {
+            return;
+        }
+        if (names.has(table.name)) {
+            throw new AuthoringError({
+                message: `query: the derived-table name ${table.name} appears twice after import splicing — rename the colliding interior (names are unique)`
+            });
+        }
+        added.add(table);
+        names.add(table.name);
+        spliced.push(table);
+    }
+    for (const table of imports) {
+        for (const inner of importInner.get(table) ?? []) {
+            add(inner);
+        }
+        add(table);
+    }
+    for (const declared of interiors) {
+        add(declared);
+    }
+    return Object.freeze(spliced);
+}
+function importAdvance(context, state, imported, bindings) {
+    const entry = importEntryOf(context, imported);
+    return advanceInterior(state, entry.table, bindings, "interior");
+}
 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`);
+        throw new AuthoringError({
+            message: `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");
 }
 function findColumns(context, entries) {
     const columns = [];
-    const derivedHead = context.kind !== "query";
+    // Nonrecursive derived stages (interiors) may emit aggregate/computed
+    // outputs (C05: "do not leave Interior.rules projection only"); ONLY the
+    // recursive feedback cycle stays projection-only — no aggregate,
+    // arithmetic-created value or negation flows through it.
+    const recName = context.kind === "rec-base" || context.kind === "rec-arm" ? context.self.name : undefined;
     for (const [name, entry] of Object.entries(entries)) {
         if (entry === undefined) {
             continue;
         }
-        if (derivedHead && !(isTerm(entry) && entry[term] === "var")) {
-            const who = context.kind === "interior" ? `interior ${context.self}` : `rec ${context.self.name}`;
-            throw errors.new(`${who}: a rec head projects bound variables only — aggregates and the measure read finished sets (unwritable here)`);
+        if (recName !== undefined && !(isTerm(entry) && entry[term] === "var")) {
+            throw new AuthoringError({
+                message: `rec ${recName}: a rec head projects bound variables only — no aggregate or arithmetic-created value flows through the feedback cycle (compute over the finished set in the main rules)`
+            });
         }
         columns.push(findColumnOf(name, entry));
     }
@@ -535,6 +770,9 @@ function findColumns(context, entries) {
 function makeRawChain(context, state) {
     const chain = {
         match(relation, bindings) {
+            if (isImportedSource(relation)) {
+                return makeRawChain(context, importAdvance(context, state, relation, bindings));
+            }
             return makeRawChain(context, advanceMatch(context, state, relation, bindings));
         },
         where(cond) {
@@ -554,6 +792,9 @@ function makeRawScope(context) {
     const scope = {
         ...termOps,
         match(relation, bindings) {
+            if (isImportedSource(relation)) {
+                return makeRawChain(context, importAdvance(context, EMPTY_RULE, relation, bindings));
+            }
             return makeRawChain(context, advanceMatch(context, EMPTY_RULE, relation, bindings));
         },
         interior(name, bindings) {
@@ -578,14 +819,14 @@ function isTypedScope(scope) {
 function makeQueryRuleScope(theory, env) {
     const raw = makeRawScope({ kind: "query", classes: theory.classes, theory, ...env });
     if (!isTypedScope(raw)) {
-        throw errors.new("query rule builder construction incomplete");
+        throw new SdkInvariantError({ message: "query rule builder construction incomplete" });
     }
     return raw;
 }
 function makeInteriorRuleScope(theory, env, self) {
     const raw = makeRawScope({ kind: "interior", self, classes: theory.classes, theory, ...env });
     if (!isTypedScope(raw)) {
-        throw errors.new("interior rule builder construction incomplete");
+        throw new SdkInvariantError({ message: "interior rule builder construction incomplete" });
     }
     return raw;
 }
@@ -606,7 +847,7 @@ function makeRecRuleScope(theory, env, self, kind) {
             ...env
         });
     if (!isTypedScope(raw)) {
-        throw errors.new("rec rule builder construction incomplete");
+        throw new SdkInvariantError({ message: "rec rule builder construction incomplete" });
     }
     return raw;
 }
@@ -618,6 +859,9 @@ function headSignature(column) {
     if (entry.kind === "var") {
         return `${column.name}:var`;
     }
+    if (entry.kind === "compute") {
+        return `${column.name}:compute`;
+    }
     const agg = entry.agg;
     if (agg.op === "fold") {
         return `${column.name}:${agg.fold}`;
@@ -656,16 +900,22 @@ function paramRegistryOf(interiors, rec, rules) {
                 continue;
             }
             if ((existing.members === undefined) !== (use.members === undefined)) {
-                throw errors.new(`query param ${use.name} collides with a membership array's registry entry — name the param differently`);
+                throw new AuthoringError({
+                    message: `query param ${use.name} collides with a membership array's registry entry — name the param differently`
+                });
             }
             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`);
+                throw new AuthoringError({
+                    message: `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 = 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`);
+                    throw new AuthoringError({
+                        message: `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`
+                    });
                 }
             }
             if (existing.anchor === undefined && use.anchor !== undefined) {
@@ -693,13 +943,13 @@ function paramRegistryOf(interiors, rec, rules) {
     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`);
+            throw new AuthoringError({ message: `query param ${name} lost its registry entry` });
         }
         let membership;
         if (entry.members !== undefined) {
             const anchor = entry.anchor;
             if (anchor === undefined) {
-                throw errors.new(`query param ${name} lost its membership anchor`);
+                throw new AuthoringError({ message: `query param ${name} lost its membership anchor` });
             }
             membership = Object.freeze({
                 kind: "set",
@@ -722,24 +972,30 @@ function paramRegistryOf(interiors, rec, rules) {
 function alignedHeadOf(label, rules) {
     const first = rules[0];
     if (first === undefined) {
-        throw errors.new(`${label} needs at least one rule`);
+        throw new AuthoringError({ message: `${label} needs at least one rule` });
     }
     const signature = first.finds.map(headSignature).join(", ");
     rules.forEach(function verifyHead(rule, index) {
         const candidate = rule.finds.map(headSignature).join(", ");
         if (candidate !== signature) {
-            throw errors.new(`every rule of ${label} derives the same head — rule 0 finds (${signature}), rule ${index} finds (${candidate})`);
+            throw new AuthoringError({
+                message: `every rule of ${label} derives the same head — rule 0 finds (${signature}), rule ${index} finds (${candidate})`
+            });
         }
         rule.finds.forEach(function verifyClosedSlice(column, position) {
             const lead = first.finds[position];
             if (lead !== undefined && column.closed !== lead.closed) {
-                throw errors.new(`every rule of ${label} derives the same head — the head column ${lead.name} is ${renderClosedSlice(lead.closed)} in rule 0 but ${renderClosedSlice(column.closed)} in rule ${index} (one column decodes through one roster)`);
+                throw new AuthoringError({
+                    message: `every rule of ${label} derives the same head — the head column ${lead.name} is ${renderClosedSlice(lead.closed)} in rule 0 but ${renderClosedSlice(column.closed)} in rule ${index} (one column decodes through one roster)`
+                });
             }
             if (lead === undefined) {
                 return;
             }
             if (lead.slot !== undefined && column.slot !== undefined && !headFieldJoins(lead.slot, column.slot)) {
-                throw errors.new(`every rule of ${label} derives the same head — the head column ${lead.name} is bound at ${renderFieldKind(lead.slot)} in rule 0 but at ${renderFieldKind(column.slot)} in rule ${index} (a head column joins class-equal slots; same-wire u64 admits a bare side, and the merged head is bare)`);
+                throw new AuthoringError({
+                    message: `every rule of ${label} derives the same head — the head column ${lead.name} is bound at ${renderFieldKind(lead.slot)} in rule 0 but at ${renderFieldKind(column.slot)} in rule ${index} (a head column joins class-equal slots; same-wire u64 admits a bare side, and the merged head is bare)`
+                });
             }
         });
     });
@@ -765,18 +1021,21 @@ function alignedHeadOf(label, rules) {
     return Object.freeze(merged);
 }
 function afterMainError(what) {
-    return errors.new(`query: ${what} after a main rule is unwritable — declaration order is interiors, then rec, then main`);
+    return new AuthoringError({
+        message: `query: ${what} after a main rule is unwritable — declaration order is interiors, then rec, then main`
+    });
 }
 function makeRawQuery(theory, interiors, rec, rules) {
     const mergedFinds = alignedHeadOf("a query", rules);
     const first = rules[0];
     if (first === undefined) {
-        throw errors.new("a query needs at least one rule");
+        throw new AuthoringError({ message: "a query needs at least one rule" });
     }
     const env = rec === undefined ? { interiors } : { interiors, rec };
-    const frozenInteriors = Object.freeze([...interiors]);
+    const allInteriors = spliceImports(interiors, rec, rules);
+    const frozenInteriors = Object.freeze([...allInteriors]);
     const frozenRules = Object.freeze([...rules]);
-    const params = paramRegistryOf(interiors, rec, rules);
+    const params = paramRegistryOf(allInteriors, rec, rules);
     const data = rec === undefined
         ? Object.freeze({
             kind: "cq",
@@ -800,6 +1059,12 @@ function makeRawQuery(theory, interiors, rec, rules) {
             const built = build(makeRawScope({ kind: "query", classes: theory.classes, theory, ...env }));
             return makeRawQuery(theory, interiors, rec, [...rules, built.rule]);
         },
+        named(label) {
+            // A diagnostic name for composition/tracing — not a schema
+            // relation, a persistent view or a separate CTE type.
+            labelImport(value, label);
+            return value;
+        },
         interior() {
             throw afterMainError("interior");
         },
@@ -815,7 +1080,7 @@ function makeQuery(theory, interiors, rec, rules) {
 }
 function collectInterior(theory, env, name, builds) {
     if (builds.length === 0) {
-        throw errors.new(`query: interior ${name} needs at least one rule`);
+        throw new AuthoringError({ message: `query: interior ${name} needs at least one rule` });
     }
     const rules = builds.map(function buildRule(buildOne) {
         return buildOne(makeInteriorRuleScope(theory, env, name)).rule;
@@ -825,10 +1090,10 @@ function collectInterior(theory, env, name, builds) {
 }
 function collectRec(theory, interiors, name, baseBuilds, recBuilds) {
     if (baseBuilds.length === 0) {
-        throw errors.new(`query: rec ${name} has no base arms`);
+        throw new AuthoringError({ message: `query: rec ${name} has no base arms` });
     }
     if (recBuilds.length === 0) {
-        throw errors.new(`query: rec ${name} has no rec arms`);
+        throw new AuthoringError({ message: `query: rec ${name} has no rec arms` });
     }
     const handle = Object.freeze({ name });
     const baseEnv = { interiors, rec: handle };
@@ -838,11 +1103,11 @@ function collectRec(theory, interiors, name, baseBuilds, recBuilds) {
     const baseFinds = alignedHeadOf(`rec ${name}`, base);
     const first = base[0];
     if (first === undefined) {
-        throw errors.new(`query: rec ${name} has no base arms`);
+        throw new AuthoringError({ message: `query: rec ${name} has no base arms` });
     }
     const firstFind = baseFinds[0];
     if (firstFind === undefined) {
-        throw errors.new(`query: rec ${name} has no head`);
+        throw new AuthoringError({ message: `query: rec ${name} has no head` });
     }
     const finds = [firstFind, ...baseFinds.slice(1)];
     const head = Object.freeze({ name, finds });
@@ -853,12 +1118,12 @@ function collectRec(theory, interiors, name, baseBuilds, recBuilds) {
     const mergedAll = alignedHeadOf(`rec ${name}`, [...base, ...rec]);
     const mergedFirst = mergedAll[0];
     if (mergedFirst === undefined) {
-        throw errors.new(`query: rec ${name} has no head`);
+        throw new AuthoringError({ message: `query: rec ${name} has no head` });
     }
     const sealedFinds = [mergedFirst, ...mergedAll.slice(1)];
     const firstRec = rec[0];
     if (firstRec === undefined) {
-        throw errors.new(`query: rec ${name} has no rec arms`);
+        throw new AuthoringError({ message: `query: rec ${name} has no rec arms` });
     }
     const sealedBase = [first, ...base.slice(1)];
     const sealedRec = [firstRec, ...rec.slice(1)];
@@ -877,10 +1142,10 @@ function makeQueryStart(theory, interiors) {
             if (interiors.some(function sameName(interior) {
                 return interior.name === name;
             })) {
-                throw errors.new(`query: interior ${name} is already declared — names are unique`);
+                throw new AuthoringError({ message: `query: interior ${name} is already declared — names are unique` });
             }
             if (name.length === 0) {
-                throw errors.new("query: an interior needs a name");
+                throw new AuthoringError({ message: "query: an interior needs a name" });
             }
             const data = collectInterior(theory, env, name, builds);
             return makeQueryStart(theory, [...interiors, data]);
@@ -889,10 +1154,10 @@ function makeQueryStart(theory, interiors) {
             if (interiors.some(function sameName(interior) {
                 return interior.name === name;
             })) {
-                throw errors.new(`query: interior and rec share the name ${name}`);
+                throw new AuthoringError({ message: `query: interior and rec share the name ${name}` });
             }
             if (name.length === 0) {
-                throw errors.new("query: reach needs a name");
+                throw new AuthoringError({ message: "query: reach needs a name" });
             }
             const data = collectRec(theory, interiors, name, arms.base, arms.rec);
             return makeQueryReachStart(theory, interiors, data);
@@ -925,11 +1190,29 @@ function taggedHandleId(context, closed, value) {
     }
     const id = closed.handles.indexOf(value);
     if (id < 0) {
-        throw errors.new(`${context}: "${value}" is not a handle of ${closed.name} — the roster is ${closed.handles.join(", ")}`);
+        throw new AuthoringError({
+            message: `${context}: "${value}" is not a handle of ${closed.name} — the roster is ${closed.handles.join(", ")}`
+        });
     }
     return { kind: "u64", value: BigInt(id) };
 }
 function taggedAtElementDomain(context, element, value) {
+    if (element === "f64") {
+        if (typeof value === "number") {
+            return { kind: "f64", value };
+        }
+        if (isFloatIntervalValue(value)) {
+            if (Number.isNaN(value.start) || Number.isNaN(value.end) || !(value.start < value.end)) {
+                throw literalShapeError(context, "a nonempty float interval with non-NaN endpoints", value);
+            }
+            return {
+                kind: "intervalF64",
+                start: Object.is(value.start, -0) ? 0 : value.start,
+                end: Object.is(value.end, -0) ? 0 : value.end
+            };
+        }
+        throw literalShapeError(context, "number (point) or { start, end } numbers (interval)", value);
+    }
     if (typeof value === "bigint") {
         if (element === "u64") {
             return { kind: "u64", value };
@@ -968,6 +1251,18 @@ function taggedLiteral(context, field, value) {
             }
             return { kind: "i64", value };
         }
+        case "f64": {
+            if (typeof value !== "number") {
+                throw literalShapeError(context, "number", value);
+            }
+            return { kind: "f64", value };
+        }
+        case "uuid": {
+            if (!Uuid.isUuid(value)) {
+                throw literalShapeError(context, "a UUID (canonical UUID text)", value);
+            }
+            return { kind: "uuid", value };
+        }
         case "str": {
             if (typeof value !== "string") {
                 throw literalShapeError(context, "string", value);
@@ -1006,6 +1301,9 @@ function taggedCmpLiteral(context, sibling, value, op) {
         isIntervalValue(value)) {
         return taggedAtElementDomain(context, sibling.kind, value);
     }
+    if (op === "pointIn" && rosterOf(sibling) === undefined && sibling.kind === "f64" && isFloatIntervalValue(value)) {
+        return taggedAtElementDomain(context, "f64", value);
+    }
     return taggedLiteral(context, sibling, value);
 }
 function freshVarIds() {
@@ -1025,18 +1323,20 @@ function freshVarIds() {
 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`);
+        throw new AuthoringError({ message: `query lowering: param ${name} is not in the query's registry` });
     }
     return id;
 }
 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`);
+        throw new AuthoringError({
+            message: `query lowering: relation ${atom.relation.name} is not the relation value schema ${ctx.theory.name} declares`
+        });
     }
     const relationId = ctx.relationIds.get(atom.relation.name);
     if (relationId === undefined) {
-        throw errors.new(`query lowering: relation ${atom.relation.name} has no ordinal`);
+        throw new AuthoringError({ message: `query lowering: relation ${atom.relation.name} has no ordinal` });
     }
     const ordered = sealedFieldsOf(atom.relation);
     const bindings = atom.bindings.map(function lowerBinding(binding) {
@@ -1044,7 +1344,9 @@ function lowerAtom(ctx, atom, ids) {
             return candidate.name === binding.field;
         });
         if (ordinal < 0) {
-            throw errors.new(`query lowering: relation ${atom.relation.name} has no field ${binding.field}`);
+            throw new AuthoringError({
+                message: `query lowering: relation ${atom.relation.name} has no field ${binding.field}`
+            });
         }
         return [ordinal, lowerBindingTerm(ctx, `${atom.relation.name}.${binding.field}`, binding, ids)];
     });
@@ -1074,17 +1376,17 @@ function lowerBindingTerm(ctx, context, binding, ids) {
 function lowerInteriorAtom(ctx, target, bindings, ids) {
     const interior = ctx.interiorIds.get(target.name);
     if (interior === undefined) {
-        throw errors.new(`query lowering: derived table ${target.name} was not declared on this query`);
+        throw new AuthoringError({ message: `query lowering: derived table ${target.name} was not declared on this query` });
     }
     if (target.finds.length === 0) {
-        throw errors.new(`query lowering: derived table ${target.name} has no head`);
+        throw new AuthoringError({ message: `query lowering: derived table ${target.name} has no head` });
     }
     const irBindings = target.finds.map(function lowerPosition(column, position) {
         const binding = bindings.find(function byKey(candidate) {
             return candidate.key === column.name;
         });
         if (binding === undefined) {
-            throw errors.new(`query lowering: interior ${target.name} omits head column ${column.name}`);
+            throw new AuthoringError({ message: `query lowering: interior ${target.name} omits head column ${column.name}` });
         }
         return [position, { kind: "var", var: ids.of(binding.ref) }];
     });
@@ -1101,7 +1403,9 @@ function lowerCmpTerm(ctx, side, sibling, ids, op) {
         case "literal": {
             const anchor = cmpAnchorOf(ctx, sibling);
             if (anchor === undefined) {
-                throw errors.new("query lowering: a comparison literal needs a bound-variable or anchored-param sibling to type it");
+                throw new AuthoringError({
+                    message: "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) };
         }
@@ -1141,10 +1445,54 @@ function lowerCondition(ctx, cond, ids) {
         })
     };
 }
+/**
+ * Lowers one computed scalar node to the C05 wire (`#native.ts`'s
+ * `ScalarExprIr`): the shared grammar arms pass through 1:1. Cached
+ * construction depth is the bound; this walk emits wire only and does
+ * not re-judge kinds (L14/native compile owns binding).
+ */
+function lowerComputeNode(node, ids) {
+    if (node.depth > MAX_COMPUTE_DEPTH) {
+        throw new AuthoringError({
+            message: `query lowering: a compute expression is deeper than ${MAX_COMPUTE_DEPTH} nodes (the engine's scalar depth bound)`
+        });
+    }
+    return lowerComputeGrammar(node, ids);
+}
+function lowerComputeGrammar(node, ids) {
+    switch (node.kind) {
+        case "var":
+            return { kind: "var", var: ids.of(node.ref) };
+        case "literal":
+            return { kind: "literal", value: literalWireOf(node.value) };
+        case "negate":
+        case "isNaN":
+        case "isFinite":
+            return { kind: node.kind, expr: lowerComputeGrammar(node.expr, ids) };
+        case "cast":
+            return { kind: "cast", cast: node.cast, expr: lowerComputeGrammar(node.expr, ids) };
+        case "add":
+        case "subtract":
+        case "multiply":
+        case "divide":
+            return {
+                kind: node.kind,
+                left: lowerComputeGrammar(node.left, ids),
+                right: lowerComputeGrammar(node.right, ids)
+            };
+        default:
+            throw new AuthoringError({
+                message: "query lowering: a query-var tree cannot carry a source-field leaf — use Compute over bound variables"
+            });
+    }
+}
 function lowerFind(entry, ids) {
     if (entry.kind === "var") {
         return { kind: "var", var: ids.of(entry.over) };
     }
+    if (entry.kind === "compute") {
+        return { kind: "compute", expr: lowerComputeNode(entry.expr, ids) };
+    }
     const agg = entry.agg;
     switch (agg.op) {
         case "count":
@@ -1170,6 +1518,9 @@ function headTermOf(column) {
     if (entry.kind === "var") {
         return { kind: "var" };
     }
+    if (entry.kind === "compute") {
+        return { kind: "compute" };
+    }
     return { kind: "aggregate", op: headOpOf(entry.agg) };
 }
 function lowerRule(ctx, rule) {
@@ -1227,7 +1578,9 @@ function lowerQuery(q) {
     const params = new Map();
     q.data.params.forEach(function assignParamId(entry, index) {
         if (entry.anchor === undefined) {
-            throw errors.new(`query param ${entry.name} has no field-anchored use — bind it in an atom or compare it against a bound variable`);
+            throw new AuthoringError({
+                message: `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);