@bjornpagen/bumbledb 0.20.2 → 1.0.0

package/src/query/lower.ts

@@ -1,7 +1,15 @@
-import * as errors from "@superbuilders/errors"
 import { sealedFieldsOf } from "#closed.ts"
+import { AuthoringError, SdkInvariantError } from "#errors.ts"
 import type { AnyClosedRoster, AnyField } from "#fields.ts"
-import { assertDeclarationOrderKey, isIntervalValue, literalShapeError, rosterOf } from "#fields.ts"
+import {
+	assertDeclarationOrderKey,
+	f64 as f64Field,
+	isFloatIntervalValue,
+	isIntervalValue,
+	literalShapeError,
+	rosterOf,
+	u64 as u64Field
+} from "#fields.ts"
 import type { ClassRecordOf, SchemaClasses } from "#law.ts"
 import type {
 	AtomIr,
@@ -13,6 +21,7 @@ import type {
 	ParsedQuery,
 	QueryParam,
 	RuleIr,
+	ScalarExprIr,
 	TaggedValue,
 	TermIr
 } from "#native.ts"
@@ -44,8 +53,10 @@ import type {
 	RuleItem
 } from "#query/atom.ts"
 import { allen, and, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts"
+import type { QueryNode } from "#query/compute.ts"
+import { computeFieldOf, computeVarsOf, isComputeExpr, MAX_COMPUTE_DEPTH } from "#query/compute.ts"
 import type { CheckFind, CheckRecFind, FindShape, HeadRecordOf, RowOfFind } from "#query/find.ts"
-import { count, max, min, pack, sum } from "#query/find.ts"
+import { count, max, mean, min, pack, sum } from "#query/find.ts"
 import { parseQueryIr } from "#query/parse-ir.ts"
 import type {
 	AnyVar,
@@ -62,14 +73,20 @@ import {
 	fieldAntiJoins,
 	fieldJoins,
 	headFieldJoins,
+	importFacadeOf,
+	importFacadeOfOwner,
 	inferred,
+	isImportedSource,
 	isTerm,
+	labelImport,
 	makeParam,
 	makeSetParam,
 	renderFieldKind,
 	term
 } from "#query/scope.ts"
+import { literalWireOf } from "#scalar.ts"
 import type { AnySchema, Schema, SchemaRelations } from "#schema.ts"
+import { Uuid } from "#uuid.ts"
 
 type QueryRelation<Rels extends SchemaRelations> = Extract<Rels[keyof Rels], MatchOwner>
 
@@ -121,6 +138,7 @@ interface TermOps {
 	readonly not: typeof not
 	readonly count: typeof count
 	readonly sum: typeof sum
+	readonly mean: typeof mean
 	readonly min: typeof min
 	readonly max: typeof max
 	readonly pack: typeof pack
@@ -147,12 +165,25 @@ interface QueryRuleScope<Rels extends SchemaRelations, Classes extends SchemaCla
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 	): QueryRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>
 
+	/**
+	 * Nonrecursive composition (chapter 34): a typed query template of the
+	 * SAME schema is a relation expression — its whole body splices as a
+	 * derived stage; every head column must be bound to a variable minted
+	 * by `v(imported)`. Naming materializes nothing.
+	 */
+	match<Q extends AnyQuery, const B extends ImportMatchShape<Q>>(
+		imported: Q,
+		bindings: B
+	): QueryRuleChain<Rels, Record<never, never>, Classes>
+
 	interior<const B extends Readonly<Record<string, AnyVar>>>(
 		name: string,
 		bindings: B & CheckInteriorBindings<B>
 	): QueryRuleChain<Rels, Record<never, never>, Classes>
 }
 
+type ImportMatchShape<Q extends AnyQuery> = Readonly<Record<keyof RowOf<Q> & string, AnyVar>>
+
 interface QueryRuleChain<
 	Rels extends SchemaRelations,
 	P extends ParamsRecord,
@@ -176,6 +207,11 @@ interface QueryRuleChain<
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 	): QueryRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>
 
+	match<Q extends AnyQuery, const B extends ImportMatchShape<Q>>(
+		imported: Q,
+		bindings: B
+	): QueryRuleChain<Rels, P, Classes>
+
 	where<const C extends AnyCond>(
 		cond: CheckCond<Classes, C> & C
 	): QueryRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>
@@ -206,6 +242,10 @@ interface InteriorRuleScope<Rels extends SchemaRelations, Classes extends Schema
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 	): InteriorRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>
+	match<Q extends AnyQuery, const B extends ImportMatchShape<Q>>(
+		imported: Q,
+		bindings: B
+	): InteriorRuleChain<Rels, Record<never, never>, Classes>
 	interior<const B extends Readonly<Record<string, AnyVar>>>(
 		name: string,
 		bindings: B & CheckInteriorBindings<B>
@@ -233,6 +273,10 @@ interface InteriorRuleChain<
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 	): InteriorRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>
+	match<Q extends AnyQuery, const B extends ImportMatchShape<Q>>(
+		imported: Q,
+		bindings: B
+	): InteriorRuleChain<Rels, P, Classes>
 	where<const C extends AnyCond>(
 		cond: CheckCond<Classes, C> & C
 	): InteriorRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>
@@ -240,7 +284,11 @@ interface InteriorRuleChain<
 		name: string,
 		bindings: B & CheckInteriorBindings<B>
 	): InteriorRuleChain<Rels, P, Classes>
-	find<const F extends FindShape>(entries: F & CheckRecFind<F>): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
+	/**
+	 * Nonrecursive derived stages emit aggregate/computed outputs too
+	 * (C05): only the RECURSIVE head stays projection-only.
+	 */
+	find<const F extends FindShape>(entries: F & CheckFind<F>): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
 }
 
 interface RecRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> extends TermOps {
@@ -260,6 +308,11 @@ interface RecRuleScope<Rels extends SchemaRelations, Classes extends SchemaClass
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 	): RecRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>
+	/** Frozen finite nonrecursive imports may feed base/step (chapter 34). */
+	match<Q extends AnyQuery, const B extends ImportMatchShape<Q>>(
+		imported: Q,
+		bindings: B
+	): RecRuleChain<Rels, Record<never, never>, Classes>
 	interior<const B extends Readonly<Record<string, AnyVar>>>(
 		name: string,
 		bindings: B & CheckInteriorBindings<B>
@@ -287,6 +340,10 @@ interface RecRuleChain<
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 	): RecRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>
+	match<Q extends AnyQuery, const B extends ImportMatchShape<Q>>(
+		imported: Q,
+		bindings: B
+	): RecRuleChain<Rels, P, Classes>
 	where<const C extends AnyCond>(
 		cond: CheckCond<Classes, C> & C
 	): RecRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>
@@ -336,6 +393,9 @@ interface Query<
 		build: (r: QueryRuleScope<Rels, Classes>) => RV
 	): Query<Rels, Row | RowOf<RV>, Flatten<Params & ParamsOf<RV>>, Classes>
 
+	/** A diagnostic name for composition/tracing — never a schema relation. */
+	named(label: string): Query<Rels, Row, Params, Classes>
+
 	interior(name: string, ...builds: never[]): never
 
 	reach(name: string, arms: never): never
@@ -395,6 +455,7 @@ const termOps: TermOps = Object.freeze({
 	not,
 	count,
 	sum,
+	mean,
 	min,
 	max,
 	pack
@@ -428,10 +489,23 @@ interface ResolvedBindings {
  * cross-binding joins mutually class-equal by transitivity.
  */
 function mintSlotOf(context: ChainContext, ref: AnyVar): ClassedField {
+	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 as AnySchema) !== 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] }
 }
@@ -443,17 +517,19 @@ function membershipSet(
 ): { readonly name: string; readonly members: readonly string[] } {
 	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<string>()
 	const members = value.map(function memberName(member) {
@@ -461,9 +537,9 @@ function membershipSet(
 			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
@@ -492,7 +568,7 @@ function resolveBindings(
 			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: BindingEntry["term"]
@@ -503,9 +579,9 @@ function resolveBindings(
 					const mint = mintSlotOf(context, ref)
 					const positionSlot: ClassedField = { 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" as const, ref })
 					vars.push(ref)
@@ -615,7 +691,9 @@ function condDataOf(cond: AnyCond, uses: ParamUse[]): CondData {
 		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" as const,
@@ -632,14 +710,14 @@ function condDataOf(cond: AnyCond, uses: ParamUse[]): CondData {
 		})
 		return Object.freeze({ kind: "tree" as const, 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: ChainContext, state: RuleBuildState, cond: AnyCond): RuleBuildState {
 	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: Readonly<Record<string, unknown>> = Object.fromEntries(
@@ -684,9 +762,9 @@ function advanceInterior(
 			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 }))
 	}
@@ -712,7 +790,7 @@ function asVarTerm(context: string, value: unknown): AnyVar {
 	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: string, entry: { readonly agg: string; readonly over?: unknown }): AggData {
@@ -722,17 +800,18 @@ function aggDataOf(name: string, entry: { readonly agg: string; readonly over?:
 	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" as const, 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" as const, 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}` })
 	}
 }
 
@@ -746,7 +825,17 @@ function findColumnOf(name: string, entry: unknown): FindColumn {
 				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" as const, expr: entry, result: entry.result }),
+			closed: undefined,
+			slot: undefined
+		})
 	}
 	if (isAggregateEntry(entry)) {
 		return Object.freeze({
@@ -756,7 +845,9 @@ function findColumnOf(name: string, entry: unknown): FindColumn {
 			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`
+	})
 }
 
 /**
@@ -764,9 +855,9 @@ function findColumnOf(name: string, entry: unknown): FindColumn {
  * § orderability): a closed reference is equality-and-membership only.
  */
 function closedOrderError(context: string, position: string, vocabulary: string): Error {
-	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: CmpKind | "binding"): op is "lt" | "le" | "gt" | "ge" | "pointIn" {
@@ -775,15 +866,17 @@ function isOrderOp(op: CmpKind | "binding"): op is "lt" | "le" | "gt" | "ge" | "
 
 function assertBound(where: string, bound: ReadonlySet<AnyVar>, ref: AnyVar): void {
 	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: string, ref: AnyVar): void {
 	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`
+		})
 	}
 }
 
@@ -795,17 +888,41 @@ function assertNotClosed(where: string, position: string, ref: AnyVar): void {
 }
 
 function assertNumeric(where: string, position: string, ref: AnyVar): void {
-	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: ChainContext, column: FindColumn): ClassedField | undefined {
 	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: ChainContext, bound: ReadonlySet<AnyVar>, column: FindColumn): void {
@@ -815,6 +932,15 @@ function validateColumn(context: ChainContext, bound: ReadonlySet<AnyVar>, colum
 		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":
@@ -823,6 +949,9 @@ function validateColumn(context: ChainContext, bound: ReadonlySet<AnyVar>, colum
 			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":
@@ -850,9 +979,9 @@ function validateCond(context: ChainContext, bound: ReadonlySet<AnyVar>, cond: C
 			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
@@ -882,23 +1011,23 @@ function validateInterior(
 	})
 	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
@@ -908,9 +1037,9 @@ function validateInterior(
 		}
 		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`
+			})
 		}
 	}
 }
@@ -918,7 +1047,7 @@ function validateInterior(
 function completeRule(context: ChainContext, state: RuleBuildState, rawColumns: readonly FindColumn[]): RuleData {
 	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): FindColumn {
 		assertDeclarationOrderKey(`${label} find column`, column.name)
@@ -930,9 +1059,9 @@ function completeRule(context: ChainContext, state: RuleBuildState, 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)`
+					})
 				}
 			}
 		}
@@ -951,14 +1080,14 @@ function makeRuleValue<Row, P extends ParamsRecord>(rule: RuleData): RuleValue<R
 }
 
 interface RawChain {
-	match(relation: MatchOwner, bindings: Readonly<Record<string, unknown>>): RawChain
+	match(relation: MatchOwner | AnyQuery, bindings: Readonly<Record<string, unknown>>): RawChain
 	where(cond: AnyCond): RawChain
 	interior(name: string, bindings: Readonly<Record<string, unknown>>): RawChain
 	find(entries: Readonly<Record<string, unknown>>): RuleValue<never, never>
 }
 
 interface RawScope extends TermOps {
-	match(relation: MatchOwner, bindings: Readonly<Record<string, unknown>>): RawChain
+	match(relation: MatchOwner | AnyQuery, bindings: Readonly<Record<string, unknown>>): RawChain
 	interior(name: string, bindings: Readonly<Record<string, unknown>>): RawChain
 }
 
@@ -997,26 +1126,30 @@ function lookupDerived(context: ChainContext, name: string): DerivedTable {
 	})
 	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(
@@ -1028,6 +1161,159 @@ function interiorAdvance(
 	return advanceInterior(state, lookupDerived(context, name), bindings, "interior")
 }
 
+/**
+ * Imported query templates as relation-expression sources (chapter 34's
+ * nonrecursive composition). The imported CQ's whole body — its inner
+ * interiors plus its main rules as one derived table — is SPLICED into the
+ * consuming query's interior roster at assembly ({@link makeRawQuery});
+ * naming does not materialize anything, and the imported template keeps its
+ * owned immutable IR. One entry is minted per imported query VALUE, so two
+ * references to the same template read one derived table.
+ */
+interface ImportEntry {
+	readonly table: InteriorData
+	readonly inner: readonly InteriorData[]
+}
+
+const importEntries = new WeakMap<object, ImportEntry>()
+const importTables = new WeakSet<InteriorData>()
+
+function importEntryOf(context: ChainContext, imported: AnyQuery): ImportEntry {
+	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: InteriorData = Object.freeze({
+		name: facade.owner.name,
+		finds: imported.data.finds,
+		rules: imported.data.rules
+	})
+	const entry: ImportEntry = 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<InteriorData, readonly InteriorData[]>()
+
+/**
+ * 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: readonly InteriorData[],
+	rec: RecData | undefined,
+	rules: readonly RuleData[]
+): readonly InteriorData[] {
+	const seen = new Set<InteriorData>()
+	const out: InteriorData[] = []
+	function walk(ruleList: readonly RuleData[]): void {
+		for (const rule of ruleList) {
+			for (const item of rule.items) {
+				if (item.kind !== "interior" && item.kind !== "negatedInterior") {
+					continue
+				}
+				const target = item.target as InteriorData
+				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: readonly InteriorData[],
+	rec: RecData | undefined,
+	rules: readonly RuleData[]
+): readonly InteriorData[] {
+	const imports = referencedImports(interiors, rec, rules)
+	if (imports.length === 0) {
+		return interiors
+	}
+	const spliced: InteriorData[] = []
+	const names = new Set<string>()
+	const added = new Set<InteriorData>()
+	function add(table: InteriorData): void {
+		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: ChainContext,
+	state: RuleBuildState,
+	imported: AnyQuery,
+	bindings: Readonly<Record<string, unknown>>
+): RuleBuildState {
+	const entry = importEntryOf(context, imported)
+	return advanceInterior(state, entry.table, bindings, "interior")
+}
+
 function notInteriorAdvance(
 	context: ChainContext,
 	state: RuleBuildState,
@@ -1035,25 +1321,28 @@ function notInteriorAdvance(
 	bindings: Readonly<Record<string, unknown>>
 ): RuleBuildState {
 	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: ChainContext, entries: Readonly<Record<string, unknown>>): FindColumn[] {
 	const columns: FindColumn[] = []
-	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))
 	}
@@ -1063,7 +1352,10 @@ function findColumns(context: ChainContext, entries: Readonly<Record<string, unk
 function makeRawChain(context: ChainContext, state: RuleBuildState): RawChain {
 	const chain: RawChain = {
 		match(relation, bindings) {
-			return makeRawChain(context, advanceMatch(context, state, relation, bindings))
+			if (isImportedSource(relation)) {
+				return makeRawChain(context, importAdvance(context, state, relation as unknown as AnyQuery, bindings))
+			}
+			return makeRawChain(context, advanceMatch(context, state, relation as MatchOwner, bindings))
 		},
 		where(cond) {
 			return makeRawChain(context, advanceWhere(context, state, cond))
@@ -1083,7 +1375,10 @@ function makeRawScope(context: ChainContext): RawScope {
 	const scope: RawScope = {
 		...termOps,
 		match(relation, bindings) {
-			return makeRawChain(context, advanceMatch(context, EMPTY_RULE, relation, bindings))
+			if (isImportedSource(relation)) {
+				return makeRawChain(context, importAdvance(context, EMPTY_RULE, relation as unknown as AnyQuery, bindings))
+			}
+			return makeRawChain(context, advanceMatch(context, EMPTY_RULE, relation as MatchOwner, bindings))
 		},
 		interior(name, bindings) {
 			return makeRawChain(context, interiorAdvance(context, EMPTY_RULE, name, bindings))
@@ -1112,7 +1407,7 @@ function makeQueryRuleScope<Rels extends SchemaRelations, Classes extends Schema
 ): QueryRuleScope<Rels, Classes> {
 	const raw = makeRawScope({ kind: "query", classes: theory.classes, theory, ...env })
 	if (!isTypedScope<QueryRuleScope<Rels, Classes>>(raw)) {
-		throw errors.new("query rule builder construction incomplete")
+		throw new SdkInvariantError({ message: "query rule builder construction incomplete" })
 	}
 	return raw
 }
@@ -1124,7 +1419,7 @@ function makeInteriorRuleScope<Rels extends SchemaRelations, Classes extends Sch
 ): InteriorRuleScope<Rels, Classes> {
 	const raw = makeRawScope({ kind: "interior", self, classes: theory.classes, theory, ...env })
 	if (!isTypedScope<InteriorRuleScope<Rels, Classes>>(raw)) {
-		throw errors.new("interior rule builder construction incomplete")
+		throw new SdkInvariantError({ message: "interior rule builder construction incomplete" })
 	}
 	return raw
 }
@@ -1164,7 +1459,7 @@ function makeRecRuleScope<Rels extends SchemaRelations, Classes extends SchemaCl
 					...env
 				})
 	if (!isTypedScope<RecRuleScope<Rels, Classes>>(raw)) {
-		throw errors.new("rec rule builder construction incomplete")
+		throw new SdkInvariantError({ message: "rec rule builder construction incomplete" })
 	}
 	return raw
 }
@@ -1178,6 +1473,9 @@ function headSignature(column: FindColumn): string {
 	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}`
@@ -1230,22 +1528,22 @@ function paramRegistryOf(
 				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) {
@@ -1274,14 +1572,14 @@ function paramRegistryOf(
 		order.map(function entryOf(name): ParamEntry {
 			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: QueryParam | undefined
 			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" as const,
@@ -1301,6 +1599,7 @@ interface RawQuery {
 	readonly schema: AnySchema
 	readonly data: QueryData
 	rule(build: (r: RawScope) => RuleValue<never, never>): RawQuery
+	named(label: string): RawQuery
 	interior(name: string, ...builds: never[]): never
 	reach(name: string, arms: never): never
 }
@@ -1316,30 +1615,30 @@ interface RawQuery {
 function alignedHeadOf(label: string, rules: readonly RuleData[]): readonly FindColumn[] {
 	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)`
+				})
 			}
 		})
 	})
@@ -1366,9 +1665,9 @@ function alignedHeadOf(label: string, rules: readonly RuleData[]): readonly Find
 }
 
 function afterMainError(what: string): Error {
-	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(
@@ -1380,12 +1679,13 @@ function makeRawQuery(
 	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: DerivedEnv = 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: QueryData =
 		rec === undefined
 			? Object.freeze({
@@ -1410,6 +1710,12 @@ function makeRawQuery(
 			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")
 		},
@@ -1437,7 +1743,7 @@ function collectInterior<Rels extends SchemaRelations, Classes extends SchemaCla
 	builds: readonly InteriorBuild<Rels, Classes>[]
 ): InteriorData {
 	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<Rels, Classes>(theory, env, name)).rule
@@ -1454,10 +1760,10 @@ function collectRec<Rels extends SchemaRelations, Classes extends SchemaClasses>
 	recBuilds: readonly RecBuild<Rels, Classes>[]
 ): RecData {
 	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: RecHandle = Object.freeze({ name })
 	const baseEnv: DerivedEnv = { interiors, rec: handle }
@@ -1467,11 +1773,11 @@ function collectRec<Rels extends SchemaRelations, Classes extends SchemaClasses>
 	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: RecHead["finds"] = [firstFind, ...baseFinds.slice(1)]
 	const head: RecHead = Object.freeze({ name, finds })
@@ -1482,12 +1788,12 @@ function collectRec<Rels extends SchemaRelations, Classes extends SchemaClasses>
 	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: RecHead["finds"] = [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: RecData["base"] = [first, ...base.slice(1)]
 	const sealedRec: RecData["rec"] = [firstRec, ...rec.slice(1)]
@@ -1515,10 +1821,10 @@ function makeQueryStart<Rels extends SchemaRelations, Classes extends SchemaClas
 					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<Rels, Classes, Flatten<P & BuildsParams<Builds>>>(theory, [...interiors, data])
@@ -1532,10 +1838,10 @@ function makeQueryStart<Rels extends SchemaRelations, Classes extends SchemaClas
 					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<Rels, Classes, Flatten<P & BuildsParams<Base> & BuildsParams<Step>>>(
@@ -1589,14 +1895,30 @@ function taggedHandleId(
 	}
 	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: string, element: "u64" | "i64", value: unknown): TaggedValue {
+function taggedAtElementDomain(context: string, element: "u64" | "i64" | "f64", value: unknown): TaggedValue {
+	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 }
@@ -1636,6 +1958,18 @@ function taggedLiteral(context: string, field: AnyField, value: unknown): Tagged
 			}
 			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)
@@ -1677,6 +2011,9 @@ function taggedCmpLiteral(context: string, sibling: AnyField, value: unknown, op
 	) {
 		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)
 }
 
@@ -1710,7 +2047,7 @@ function freshVarIds(): VarIds {
 function paramIdOf(ctx: LowerContext, name: string): number {
 	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
 }
@@ -1718,13 +2055,13 @@ function paramIdOf(ctx: LowerContext, name: string): number {
 function lowerAtom(ctx: LowerContext, atom: AtomData, ids: VarIds): AtomIr {
 	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: Array<readonly [number, TermIr]> = atom.bindings.map(function lowerBinding(binding) {
@@ -1732,7 +2069,9 @@ function lowerAtom(ctx: LowerContext, atom: AtomData, ids: VarIds): AtomIr {
 			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)] as const
 	})
@@ -1769,17 +2108,17 @@ function lowerInteriorAtom(
 ): AtomIr {
 	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: Array<readonly [number, TermIr]> = 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) } as const] as const
 	})
@@ -1797,9 +2136,9 @@ function lowerCmpTerm(ctx: LowerContext, side: CmpTermData, sibling: CmpTermData
 		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) }
 		}
@@ -1843,10 +2182,56 @@ function lowerCondition(ctx: LowerContext, cond: CondData, ids: VarIds): Conditi
 	}
 }
 
+/**
+ * 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: QueryNode, ids: VarIds): ScalarExprIr {
+	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: QueryNode, ids: VarIds): ScalarExprIr {
+	switch (node.kind) {
+		case "var":
+			return { kind: "var", var: ids.of(node.ref as AnyVar) }
+		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: FindEntryData, ids: VarIds): FindTermIr {
 	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":
@@ -1874,6 +2259,9 @@ function headTermOf(column: FindColumn): HeadTermIr {
 	if (entry.kind === "var") {
 		return { kind: "var" }
 	}
+	if (entry.kind === "compute") {
+		return { kind: "compute" }
+	}
 	return { kind: "aggregate", op: headOpOf(entry.agg) }
 }
 
@@ -1933,9 +2321,9 @@ function lowerQuery(q: AnyQuery): ParsedQuery {
 	const params = new Map<string, ParamEntry>()
 	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)