@bjornpagen/bumbledb 0.10.0 → 0.11.0

package/src/query/lower.ts

@@ -18,11 +18,8 @@
  * `Params` inferred to be EXACTLY the params the rules use (params are typed
  * BY USE; a param no rule uses never registers). Variable IDENTITY is the
  * object reference: reusing one value across binding positions IS the join,
- * and a name-collision join is unrepresentable. Each binding position is
- * judged against the variable's MINT slot — and because {@link JoinOk} is an
- * equality, that alone makes every cross-binding join transitively
- * class-equal. Lowering is a pure function of the query value down to the
- * bridge's `ProgramIr` (`bumbledb/crates/bumbledb/src/ir.rs`): relations by
+ * lowering is a pure function of the query value down to the
+ * bridge's `QueryIr` (`bumbledb/crates/bumbledb/src/ir.rs`): relations by
  * declaration ordinal, variables by dense per-rule first-occurrence ids
  * (keyed on the object REFERENCE — the discipline is unchanged, only the map
  * key moved from name to reference), params by first-use order. Lowering is
@@ -30,7 +27,7 @@
  * two identically-written queries (fresh mints each) lower identically.
  * Construction validates negation safety and boundness (typed by the var's
  * label — object identity is invisible to the type tier, so these are
- * construction-time walls); everything else (strata, types, aggregate
+ * construction-time walls); everything else (types, aggregate
  * rosters, rule caps) is the ENGINE's judge, surfacing at prepare.
  */
 
@@ -46,8 +43,7 @@ import type {
 	FindTermIr,
 	HeadOpIr,
 	HeadTermIr,
-	PredicateDefIr,
-	ProgramIr,
+	ParsedQuery,
 	QueryParam,
 	RuleIr,
 	TaggedValue,
@@ -66,36 +62,30 @@ import type {
 	CmpTermData,
 	CondData,
 	CondParamsShape,
+	DerivedTable,
 	FindColumn,
 	FindEntryData,
-	MaskData,
+	InteriorData,
 	MatchFields,
 	MatchOwner,
 	MatchShape,
 	ParamUse,
 	RecData,
+	RecHandle,
+	RecHead,
 	RuleData,
 	RuleItem
 } from "#query/atom.ts"
 import { allen, and, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts"
 import type { CheckFind, CheckRecFind, FindShape, HeadRecordOf, RowOfFind } from "#query/find.ts"
-import { argMax, argMin, count, countDistinct, max, min, pack, sum } from "#query/find.ts"
-import type {
-	AnyVar,
-	ClassedField,
-	Flatten,
-	InferredOf,
-	JoinOk,
-	MintSlotOf,
-	ParamEntry,
-	ParamsRecord
-} from "#query/scope.ts"
+import { count, max, min, pack, sum } from "#query/find.ts"
+import { parseQueryIr } from "#query/parse-ir.ts"
+import type { AnyVar, ClassedField, Flatten, InferredOf, ParamEntry, ParamsRecord, ShapeOf } from "#query/scope.ts"
 import {
 	fieldJoins,
 	inferred,
 	isTerm,
 	makeDuration,
-	makeMaskParam,
 	makeParam,
 	makeSetParam,
 	renderFieldKind,
@@ -117,16 +107,16 @@ type ParamsOf<T> = InferredOf<T> extends { readonly params: infer P extends Para
 type RowOf<T> = InferredOf<T> extends { readonly row: infer R } ? R : never
 
 /**
- * A recursive predicate's HEAD signature as classed slots, keyed by column
- * name — carried on the rec reference so an `idb` join can be judged against
- * it; `undefined` on values that carry no head.
+ * A derived table's HEAD signature as classed slots, keyed by column
+ * name; `undefined` on values that carry no head.
  */
 type HeadShape = Readonly<Record<string, ClassedField>> | undefined
 
 /**
  * One finished rule as a plain value: the runtime data plus the inferred
- * row/params carrier (and, for a RECURSIVE rule, the head record of classed
- * slots `idb` pairs against). `.rule(...)` consumes it.
+ * row/params carrier (and, for an interior or recursive rule, the head
+ * record of classed slots an `.interior(name)` join pairs against).
+ * `.rule(...)` consumes it.
  */
 interface RuleValue<Row, P extends ParamsRecord, Head extends HeadShape = undefined> {
 	readonly rule: RuleData
@@ -140,48 +130,34 @@ type AnyRuleValue = RuleValue<unknown, ParamsRecord, HeadShape>
 type HeadOf<T> =
 	InferredOf<T> extends { readonly head: infer H extends Readonly<Record<string, ClassedField>> } ? H : undefined
 
+/** One `.interior(name)` position's judgment: a variable. */
+type InteriorBindingOk<V> = V extends AnyVar ? true : false
+
 /**
- * A recursive predicate REFERENCE — the shape `idb()` targets carry: the
- * name (type-level identity), the runtime data (value identity), the params
- * its rules have used, and the head signature its FIRST rule sealed.
+ * The validated `.interior(name)` bindings record: every entry must be a
+ * variable. Arity and class against the named table's head are
+ * construction-time (the name is a string, so the head is not a type-level
+ * fact).
  */
-interface RecRef<Name extends string, P extends ParamsRecord, Head extends HeadShape = HeadShape> {
-	readonly name: Name
-	readonly data: RecData
-	readonly [inferred]?: { readonly params: P; readonly head: Head }
+type CheckInteriorBindings<B> = {
+	readonly [K in keyof B]: InteriorBindingOk<B[K]> extends true ? B[K] : never
 }
 
-/** One `idb` position's judgment: a variable class-equal to the head slot when the head is carried. */
-type IdbBindingOk<Classes extends SchemaClasses, HeadSlot, V> = V extends AnyVar
-	? HeadSlot extends ClassedField
-		? JoinOk<HeadSlot, MintSlotOf<Classes, V>> extends true
-			? true
-			: false
-		: true
-	: false
+/** One interior-rule builder function. */
+type InteriorBuild<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> = (
+	r: InteriorRuleScope<Rels, Classes>
+) => AnyRuleValue
 
-/**
- * The validated `idb` bindings record: when the target carries its head
- * (a threaded rec handle), the record's key set must EXACTLY equal the
- * head's (a missing or extra key maps every property to `never`) and each
- * variable must be class-equal to its head slot — the same wall `JoinOk`
- * holds for EDB atoms. An unthreaded handle carries no head; every entry
- * must still be a variable, arity/class judged at construction and prepare.
- */
-type CheckIdbBindings<Classes extends SchemaClasses, Head, B> =
-	Head extends Readonly<Record<string, ClassedField>>
-		? [keyof B] extends [keyof Head]
-			? [keyof Head] extends [keyof B]
-				? {
-						readonly [K in keyof B]: K extends keyof Head
-							? IdbBindingOk<Classes, Head[K], B[K]> extends true
-								? B[K]
-								: never
-							: never
-					}
-				: { readonly [K in keyof B]: never }
-			: { readonly [K in keyof B]: never }
-		: { readonly [K in keyof B]: B[K] extends AnyVar ? B[K] : never }
+/** One rec-arm builder function. */
+type RecBuild<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> = (
+	r: RecRuleScope<Rels, Classes>
+) => AnyRuleValue
+
+/** A build function's rule value. */
+type BuiltRule<F> = F extends (r: never) => infer RV ? RV : never
+
+/** The intersected params record of a tuple of rule builds. */
+type BuildsParams<Builds extends readonly ((r: never) => AnyRuleValue)[]> = ShapeOf<ParamsOf<BuiltRule<Builds[number]>>>
 
 /**
  * The term/predicate/aggregate constructor vocabulary every rule builder
@@ -193,8 +169,6 @@ interface TermOps {
 	readonly param: typeof makeParam
 	/** Names one ∈-set parameter (the IR's `ParamSet`): bound to a readonly array at execution. */
 	readonly inSet: typeof makeSetParam
-	/** Names one Allen-mask parameter (`MaskTerm::Param`): a bind-time 13-bit mask number. */
-	readonly maskParam: typeof makeMaskParam
 	/** The measure of an interval-typed variable: `|[s, e)| = e − s`, u64. */
 	readonly duration: typeof makeDuration
 	readonly eq: typeof eq
@@ -209,12 +183,9 @@ interface TermOps {
 	readonly or: typeof or
 	readonly not: typeof not
 	readonly count: typeof count
-	readonly countDistinct: typeof countDistinct
 	readonly sum: typeof sum
 	readonly min: typeof min
 	readonly max: typeof max
-	readonly argMax: typeof argMax
-	readonly argMin: typeof argMin
 	readonly pack: typeof pack
 }
 
@@ -225,6 +196,16 @@ interface QueryRuleScope<Rels extends SchemaRelations, Classes extends SchemaCla
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 	): QueryRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>
+	/**
+	 * A rule may START with a finished table: an interior atom is a positive
+	 * occurrence exactly as the engine represents it, so its variables ground
+	 * — the identity projection `(c) | reach(c);` is spellable with no
+	 * re-grounding join over a domain relation.
+	 */
+	interior<const B extends Readonly<Record<string, AnyVar>>>(
+		name: string,
+		bindings: B & CheckInteriorBindings<B>
+	): QueryRuleChain<Rels, Record<never, never>, Classes>
 }
 
 /** The chain of a plain query rule: more atoms, residual predicates, then the head. */
@@ -242,30 +223,30 @@ interface QueryRuleChain<
 	where<const C extends AnyCond>(
 		cond: CheckCond<Classes, C> & C
 	): QueryRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>
+	/** One interior atom over a finished table (an earlier interior, or the rec). */
+	interior<const B extends Readonly<Record<string, AnyVar>>>(
+		name: string,
+		bindings: B & CheckInteriorBindings<B>
+	): QueryRuleChain<Rels, P, Classes>
 	/** The head projection: a `find` RECORD whose keys name the answer columns. */
 	find<const F extends FindShape>(entries: F & CheckFind<F>): RuleValue<RowOfFind<F>, P>
 }
 
-/** The rule builder an OUTPUT rule of a `program()` receives: a query rule plus finished-stratum `idb` atoms. */
-interface OutputRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> extends TermOps {
+/** The rule builder an `interior("mid", ...)` callback receives. */
+interface InteriorRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses>
+	extends TermOps {
 	match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
-	): OutputRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>
-	/**
-	 * A rule may START with the finished stratum: an idb atom is a positive
-	 * occurrence exactly as the engine represents it, so its variables ground
-	 * — the identity projection `(c) | reach(c);` is spellable with no
-	 * re-grounding join over a domain relation.
-	 */
-	idb<Target extends RecRef<string, ParamsRecord>, const B extends Readonly<Record<string, AnyVar>>>(
-		target: Target,
-		bindings: B & CheckIdbBindings<Classes, HeadOf<Target>, B>
-	): OutputRuleChain<Rels, ParamsOf<Target>, Classes>
+	): InteriorRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>
+	interior<const B extends Readonly<Record<string, AnyVar>>>(
+		name: string,
+		bindings: B & CheckInteriorBindings<B>
+	): InteriorRuleChain<Rels, Record<never, never>, Classes>
 }
 
-/** The chain of an output rule: atoms, predicates, `idb` joins over the program's recs, then the head. */
-interface OutputRuleChain<
+/** The chain of an interior rule: bound-variable heads only. */
+interface InteriorRuleChain<
 	Rels extends SchemaRelations,
 	P extends ParamsRecord,
 	Classes extends SchemaClasses = SchemaClasses
@@ -273,70 +254,65 @@ interface OutputRuleChain<
 	match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
-	): OutputRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>
+	): InteriorRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>
 	where<const C extends AnyCond>(
 		cond: CheckCond<Classes, C> & C
-	): OutputRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>
-	/**
-	 * One `idb` atom over a FINISHED stratum (any rec of this program): a
-	 * NAMED join against the rec's head — the bindings record's keys are the
-	 * head columns, each bound to a variable positively bound by a relation
-	 * atom of the rule. Threading the rec value the last `.rule(...)` returned
-	 * carries its params into `Params` AND its head signature, so the join is
-	 * key-exact and class-checked against the head at compile time.
-	 */
-	idb<Target extends RecRef<string, ParamsRecord>, const B extends Readonly<Record<string, AnyVar>>>(
-		target: Target,
-		bindings: B & CheckIdbBindings<Classes, HeadOf<Target>, B>
-	): OutputRuleChain<Rels, Flatten<P & ParamsOf<Target>>, Classes>
-	find<const F extends FindShape>(entries: F & CheckFind<F>): RuleValue<RowOfFind<F>, P>
+	): InteriorRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>
+	interior<const B extends Readonly<Record<string, AnyVar>>>(
+		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>>
 }
 
-/** The rule builder a RECURSIVE rule (`rec.rule(...)`) receives. */
-interface RecRuleScope<Rels extends SchemaRelations, Self extends string, Classes extends SchemaClasses = SchemaClasses>
-	extends TermOps {
+/** The rule builder a `recursive("reach", { base, rec })` arm receives. */
+interface RecRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> extends TermOps {
 	match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
-	): RecRuleChain<Rels, Self, BindParamsShape<MatchFields<R>, B>, Classes>
+	): RecRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>
+	interior<const B extends Readonly<Record<string, AnyVar>>>(
+		name: string,
+		bindings: B & CheckInteriorBindings<B>
+	): RecRuleChain<Rels, Record<never, never>, Classes>
 }
 
 /**
- * The chain of a recursive rule. Its `idb` accepts ONLY the rec itself (the
- * self-recursion cut) and its `find` takes bound variables only — aggregates
- * and the measure are unrepresentable in a recursive head.
+ * The chain of a recursive arm. `.interior("reach", …)` is the self-atom
+ * on rec arms (and a prior interior on either list). `find` takes bound
+ * variables only — aggregates and the measure are unrepresentable in a
+ * recursive head.
  */
 interface RecRuleChain<
 	Rels extends SchemaRelations,
-	Self extends string,
 	P extends ParamsRecord,
 	Classes extends SchemaClasses = SchemaClasses
 > {
 	match<R extends QueryRelation<Rels>, const B extends MatchShape<MatchFields<R>>>(
 		relation: R,
 		bindings: B & CheckBindings<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
-	): RecRuleChain<Rels, Self, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>
+	): RecRuleChain<Rels, Flatten<P & BindParamsShape<MatchFields<R>, B>>, Classes>
 	where<const C extends AnyCond>(
 		cond: CheckCond<Classes, C> & C
-	): RecRuleChain<Rels, Self, Flatten<P & CondParamsShape<C>>, Classes>
-	/** The self-recursive atom: `idb(self, { headKey: boundVar })` — only this rec's own reference is accepted. */
-	idb<Target extends RecRef<Self, ParamsRecord>, const B extends Readonly<Record<string, AnyVar>>>(
-		target: Target,
-		bindings: B & CheckIdbBindings<Classes, HeadOf<Target>, B>
-	): RecRuleChain<Rels, Self, P, Classes>
-	/** The recursive head: a `find` record of bound variables only; the value carries the head's classed slots for `idb` pairing. */
+	): RecRuleChain<Rels, Flatten<P & CondParamsShape<C>>, Classes>
+	interior<const B extends Readonly<Record<string, AnyVar>>>(
+		name: string,
+		bindings: B & CheckInteriorBindings<B>
+	): RecRuleChain<Rels, P, Classes>
 	find<const F extends FindShape>(entries: F & CheckRecFind<F>): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
 }
 
 /** A query's runtime description — everything lowering, the wire marshal, and answer decode read. */
 interface QueryData {
-	/** The program's recursive predicates in declaration order (empty for a plain query); `PredId` = index. */
-	readonly recs: readonly RecData[]
-	/** The output rules in written order (multiple rules = set union). */
+	/** Named interiors in declaration order (DAG). */
+	readonly interiors: readonly InteriorData[]
+	/** The optional linear rec. */
+	readonly rec: RecData | null
+	/** The main rules in written order (multiple rules = set union). */
 	readonly rules: readonly RuleData[]
 	/** The head columns (every rule derives the same head; written order = answer column order). */
 	readonly finds: readonly FindColumn[]
-	/** The registered params in first-use order across the program walk (= dense `ParamId`s). */
+	/** The registered params in first-use order across the query walk (= dense `ParamId`s). */
 	readonly params: readonly ParamEntry[]
 }
 
@@ -357,6 +333,10 @@ interface Query<
 	rule<RV extends AnyRuleValue>(
 		build: (r: QueryRuleScope<Rels, Classes>) => RV
 	): Query<Rels, Row | RowOf<RV>, Flatten<Params & ParamsOf<RV>>, Classes>
+	/** Construction error: interiors precede main rules. Uncallable after `.rule()`. */
+	interior(name: string, ...builds: never[]): never
+	/** Construction error: recursive precedes main rules. Uncallable after `.rule()`. */
+	recursive(name: string, arms: never): never
 	readonly [inferred]?: { readonly row: Row; readonly params: Params }
 }
 
@@ -372,18 +352,43 @@ type QueryRow<Q extends AnyQuery> = RowOf<Q>
 /** Extracts a query value's inferred execute-params type. */
 type QueryParams<Q extends AnyQuery> = ParamsOf<Q>
 
-/** The entry value of `query(S)`: the first `.rule` mints the query. */
-interface QueryStart<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> {
+/**
+ * The entry value of `query(S)`: interiors, then optional recursive, then
+ * the first `.rule` mints the query. `interior` / `recursive` exist only
+ * while `Rec` is `null`; `.recursive()` moves the type parameter.
+ */
+type QueryStart<
+	Rels extends SchemaRelations,
+	Classes extends SchemaClasses = SchemaClasses,
+	P extends ParamsRecord = Record<never, never>,
+	Rec extends RecData | null = null
+> = {
 	rule<RV extends AnyRuleValue>(
 		build: (r: QueryRuleScope<Rels, Classes>) => RV
-	): Query<Rels, RowOf<RV>, ParamsOf<RV>, Classes>
-}
+	): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes>
+} & (Rec extends null
+	? {
+			interior<const Builds extends readonly InteriorBuild<Rels, Classes>[]>(
+				name: string,
+				...builds: Builds
+			): QueryStart<Rels, Classes, Flatten<P & BuildsParams<Builds>>, null>
+			recursive<
+				const Base extends readonly RecBuild<Rels, Classes>[],
+				const Step extends readonly RecBuild<Rels, Classes>[]
+			>(
+				name: string,
+				arms: { readonly base: Base; readonly rec: Step }
+			): QueryStart<Rels, Classes, Flatten<P & BuildsParams<Base> & BuildsParams<Step>>, RecData>
+		}
+	: {
+			interior: never
+			recursive: never
+		})
 
 /** The frozen constructor vocabulary every rule builder spreads. */
 const termOps: TermOps = Object.freeze({
 	param: makeParam,
 	inSet: makeSetParam,
-	maskParam: makeMaskParam,
 	duration: makeDuration,
 	eq,
 	ne,
@@ -397,12 +402,9 @@ const termOps: TermOps = Object.freeze({
 	or,
 	not,
 	count,
-	countDistinct,
 	sum,
 	min,
 	max,
-	argMax,
-	argMin,
 	pack
 })
 
@@ -558,10 +560,6 @@ function resolveBindings(
 					)
 					break
 				}
-				case "maskParam":
-					throw errors.new(
-						`${label}.${fieldName}: an Allen-mask param is not a field-typed value — masks live in allen() conditions only`
-					)
 				case "duration":
 					throw errors.new(
 						`${label}.${fieldName}: the measure is not a field-typed value — it lives in comparisons and find entries`
@@ -607,7 +605,7 @@ function advanceMatch(
 }
 
 /** Resolves one comparison side to its runtime term (variables and the measure ride by reference). */
-function cmpTermDataOf(op: string, value: unknown): CmpTermData {
+function cmpTermDataOf(value: unknown): CmpTermData {
 	if (isTerm(value)) {
 		switch (value[term]) {
 			case "var":
@@ -618,8 +616,6 @@ function cmpTermDataOf(op: string, value: unknown): CmpTermData {
 				return Object.freeze({ kind: "setParam" as const, name: value.name })
 			case "duration":
 				return Object.freeze({ kind: "measure" as const, ref: value.over })
-			case "maskParam":
-				throw errors.new(`${op}: an Allen-mask param is not a comparison term — masks live in allen()'s mask position`)
 		}
 	}
 	return Object.freeze({ kind: "literal" as const, value })
@@ -656,31 +652,23 @@ function sideUses(op: CmpKind, side: CmpTermData, sibling: CmpTermData, uses: Pa
 /** Lowers one condition VALUE to its runtime data, recording param uses. */
 function condDataOf(cond: AnyCond, uses: ParamUse[]): CondData {
 	if (cond.cond === "cmp") {
-		const lhs = cmpTermDataOf(cond.op, cond.lhs)
-		const rhs = cmpTermDataOf(cond.op, cond.rhs)
+		const lhs = cmpTermDataOf(cond.lhs)
+		const rhs = cmpTermDataOf(cond.rhs)
 		sideUses(cond.op, lhs, rhs, uses)
 		sideUses(cond.op, rhs, lhs, uses)
-		let mask: MaskData | undefined
 		if (cond.op === "allen") {
 			const maskValue = cond.mask
-			if (typeof maskValue === "number") {
-				mask = Object.freeze({ kind: "literal" as const, mask: maskValue })
-			} else if (isTerm(maskValue) && maskValue[term] === "maskParam") {
-				mask = Object.freeze({ kind: "param" as const, name: maskValue.name })
-				uses.push(
-					Object.freeze({
-						name: maskValue.name,
-						shape: "mask" as const,
-						anchor: undefined,
-						op: "allen" as const,
-						members: undefined
-					})
-				)
-			} else {
-				throw errors.new("allen: the mask position takes a 13-bit mask number or a maskParam")
+			if (typeof maskValue !== "number") {
+				throw errors.new("allen: the mask position takes a 13-bit mask number built from the ALLEN constants")
 			}
+			return Object.freeze({
+				kind: "cmp" as const,
+				op: { kind: "allen" as const, mask: maskValue },
+				lhs,
+				rhs
+			})
 		}
-		return Object.freeze({ kind: "cmp" as const, op: cond.op, mask, lhs, rhs })
+		return Object.freeze({ kind: "cmp" as const, op: { kind: cond.op }, lhs, rhs })
 	}
 	if (cond.cond === "tree") {
 		const children = cond.children.map(function lowerChild(child) {
@@ -698,13 +686,13 @@ function advanceWhere(context: ChainContext, state: RuleBuildState, cond: AnyCon
 	if (typeof cond !== "object" || cond === null || !("cond" in cond)) {
 		throw errors.new("where() takes a comparison, an and()/or() tree, or a negated atom")
 	}
-	if (cond.cond === "notIdb") {
+	if (cond.cond === "notInterior") {
 		const bindings: Readonly<Record<string, unknown>> = Object.fromEntries(
 			Object.entries(cond.bindings ?? {}).filter(function defined([, value]) {
 				return value !== undefined
 			})
 		)
-		return notIdbAdvance(context, state, cond.target, bindings)
+		return notInteriorAdvance(context, state, cond.name, bindings)
 	}
 	if (cond.cond === "not") {
 		const relation: MatchOwner = cond.relation
@@ -730,19 +718,19 @@ function advanceWhere(context: ChainContext, state: RuleBuildState, cond: AnyCon
 }
 
 /**
- * Extends a rule state with one `idb` atom (a named record over head keys;
- * vars validated at completion). A POSITIVE idb atom is a positive
- * occurrence exactly as the engine represents it (`check_atoms` walks Idb
+ * Extends a rule state with one interior atom (a named record over head keys;
+ * vars validated at completion). A POSITIVE interior atom is a positive
+ * occurrence exactly as the engine represents it (`check_atoms` walks Interior
  * and Edb in one loop), so its variables GROUND: they enter the rule's
  * boundness set, may ride the head, and satisfy negation safety — the
- * idb-only identity projection of a finished stratum is spellable with no
+ * interior-only identity projection of a finished table is spellable with no
  * re-grounding join. A NEGATED one binds nothing, only rejects.
  */
-function advanceIdb(
+function advanceInterior(
 	state: RuleBuildState,
-	rec: RecData,
+	target: DerivedTable,
 	bindings: Readonly<Record<string, unknown>>,
-	negated: boolean
+	kind: "interior" | "negatedInterior"
 ): RuleBuildState {
 	const resolved: Array<{ readonly key: string; readonly ref: AnyVar }> = []
 	for (const [key, value] of Object.entries(bindings)) {
@@ -751,31 +739,26 @@ function advanceIdb(
 		}
 		if (!isTerm(value) || value[term] !== "var") {
 			throw errors.new(
-				`idb ${rec.name}: position ${key} takes a variable — bind literals and params through where()/match()`
+				`interior ${target.name}: position ${key} takes a variable — bind literals and params through where()/match()`
 			)
 		}
 		resolved.push(Object.freeze({ key, ref: value }))
 	}
 	const bound = new Set(state.bound)
-	if (!negated) {
+	if (kind === "interior") {
 		for (const binding of resolved) {
 			bound.add(binding.ref)
 		}
 	}
 	return Object.freeze({
-		items: Object.freeze([
-			...state.items,
-			Object.freeze({ kind: "idb" as const, rec, bindings: Object.freeze(resolved), negated })
-		]),
+		items: Object.freeze([...state.items, Object.freeze({ kind, target, bindings: Object.freeze(resolved) })]),
 		bound,
 		paramUses: state.paramUses
 	})
 }
 
 /** Narrows a find entry to an aggregate value. */
-function isAggregateEntry(
-	value: unknown
-): value is { readonly agg: string; readonly over: unknown; readonly key: unknown } {
+function isAggregateEntry(value: unknown): value is { readonly agg: string; readonly over: unknown } {
 	return typeof value === "object" && value !== null && "agg" in value
 }
 
@@ -788,16 +771,11 @@ function asVarTerm(context: string, value: unknown): AnyVar {
 }
 
 /** Classifies one aggregate find entry into its runtime data (variables ride by reference). */
-function aggDataOf(
-	name: string,
-	entry: { readonly agg: string; readonly over: unknown; readonly key: unknown }
-): AggData {
+function aggDataOf(name: string, entry: { readonly agg: string; readonly over: unknown }): AggData {
 	const over = entry.over
 	switch (entry.agg) {
 		case "count":
 			return Object.freeze({ op: "count" as const })
-		case "countDistinct":
-			return Object.freeze({ op: "countDistinct" as const, over: asVarTerm(`find ${name} (countDistinct)`, over) })
 		case "sum":
 		case "min":
 		case "max": {
@@ -809,14 +787,6 @@ function aggDataOf(
 			}
 			throw errors.new(`find ${name} (${entry.agg}): takes a variable or r.duration(v)`)
 		}
-		case "argMax":
-		case "argMin":
-			return Object.freeze({
-				op: "arg" as const,
-				direction: entry.agg,
-				over: asVarTerm(`find ${name} (${entry.agg})`, over),
-				key: asVarTerm(`find ${name} (${entry.agg} key)`, entry.key)
-			})
 		case "pack":
 			return Object.freeze({ op: "pack" as const, over: asVarTerm(`find ${name} (pack)`, over) })
 		default:
@@ -903,17 +873,14 @@ function assertNotClosed(where: string, position: string, ref: AnyVar): void {
 
 /**
  * The classed mint slot one answer column's VALUES flow from: a projected
- * variable's mint slot, or an Arg-carried payload's. Counts, folds, `pack`
- * and the measure derive numbers/intervals, so they resolve no slot.
+ * variable's mint slot. Counts, folds, `pack` and the measure derive
+ * numbers/intervals, so they resolve no slot.
  */
 function findColumnSlotOf(context: ChainContext, column: FindColumn): ClassedField | undefined {
 	const entry = column.entry
 	if (entry.kind === "var") {
 		return mintSlotOf(context, entry.over)
 	}
-	if (entry.kind === "aggregate" && entry.agg.op === "arg") {
-		return mintSlotOf(context, entry.agg.over)
-	}
 	return undefined
 }
 
@@ -934,9 +901,6 @@ function validateColumn(context: ChainContext, bound: ReadonlySet<AnyVar>, colum
 	switch (agg.op) {
 		case "count":
 			return
-		case "countDistinct":
-			assertBound(where, bound, agg.over)
-			return
 		case "fold": {
 			if ("duration" in agg.over) {
 				assertBound(where, bound, agg.over.duration)
@@ -947,12 +911,6 @@ function validateColumn(context: ChainContext, bound: ReadonlySet<AnyVar>, colum
 			assertNotClosed(where, `the ${agg.fold} input`, agg.over)
 			return
 		}
-		case "arg": {
-			assertBound(where, bound, agg.over)
-			assertBound(where, bound, agg.key)
-			assertNotClosed(where, `the ${agg.direction} key`, agg.key)
-			return
-		}
 		case "pack":
 			assertBound(where, bound, agg.over)
 			assertInterval(where, agg.over)
@@ -972,8 +930,8 @@ function validateCond(context: ChainContext, bound: ReadonlySet<AnyVar>, cond: C
 			if (side.kind === "var") {
 				assertBound(label, bound, side.ref)
 				const roster = rosterOf(side.ref.field)
-				if (isOrderOp(cond.op) && roster !== undefined) {
-					throw closedOrderError(label, `the ${cond.op} side ${side.ref.label}`, roster.name)
+				if (isOrderOp(cond.op.kind) && roster !== undefined) {
+					throw closedOrderError(label, `the ${cond.op.kind} side ${side.ref.label}`, roster.name)
 				}
 			}
 			if (side.kind === "measure") {
@@ -981,14 +939,14 @@ function validateCond(context: ChainContext, bound: ReadonlySet<AnyVar>, cond: C
 				assertInterval(label, side.ref)
 			}
 		}
-		if ((cond.op === "eq" || cond.op === "ne") && cond.lhs.kind === "var" && cond.rhs.kind === "var") {
+		if ((cond.op.kind === "eq" || cond.op.kind === "ne") && cond.lhs.kind === "var" && cond.rhs.kind === "var") {
 			assertBound(label, bound, cond.lhs.ref)
 			assertBound(label, bound, cond.rhs.ref)
 			const lhs = mintSlotOf(context, cond.lhs.ref)
 			const rhs = mintSlotOf(context, cond.rhs.ref)
 			if (!fieldJoins(lhs, rhs)) {
 				throw errors.new(
-					`${label}: ${cond.op}(${cond.lhs.ref.label}, ${cond.rhs.ref.label}) unifies domain-unequal fields — ${cond.lhs.ref.label} bound at ${renderFieldKind(lhs)}, ${cond.rhs.ref.label} at ${renderFieldKind(rhs)} (a var joins only class-equal slots; bare pairs only with bare)`
+					`${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)`
 				)
 			}
 		}
@@ -1000,29 +958,27 @@ function validateCond(context: ChainContext, bound: ReadonlySet<AnyVar>, cond: C
 }
 
 /**
- * Validates one `idb` item: every head column of the rec is bound exactly
+ * Validates one interior item: every head column of the table is bound exactly
  * once (a missing or extra key is a pointed error) and each variable joins
- * its head column's classed slot. A POSITIVE idb atom GROUNDS its
+ * its head column's classed slot. A POSITIVE interior atom GROUNDS its
  * variables (a positive occurrence, exactly the engine's representation),
  * so no boundness precondition exists; a NEGATED one binds nothing — its
  * variables must be positively bound elsewhere in the rule, the same
- * safety rule as EDB negation. When the rec's own rule 0 is in flight
- * (`rec.rules[0]` absent), the completing rule's OWN find columns ARE the
- * head.
+ * safety rule as EDB negation. When the table's own first rule is in flight
+ * (`finds` empty), the completing rule's OWN find columns ARE the head.
  */
-function validateIdb(
+function validateInterior(
 	context: ChainContext,
 	bound: ReadonlySet<AnyVar>,
 	item: {
-		readonly rec: RecData
+		readonly kind: "interior" | "negatedInterior"
+		readonly target: DerivedTable
 		readonly bindings: ReadonlyArray<{ readonly key: string; readonly ref: AnyVar }>
-		readonly negated: boolean
 	},
 	columns: readonly FindColumn[]
 ): void {
 	const label = contextLabel(context)
-	const head = item.rec.rules[0]
-	const headColumns = head !== undefined ? head.finds : columns
+	const headColumns = item.target.finds.length > 0 ? item.target.finds : columns
 	const headNames = headColumns.map(function nameOf(column) {
 		return column.name
 	})
@@ -1032,21 +988,21 @@ function validateIdb(
 	for (const key of keys) {
 		if (!headNames.includes(key)) {
 			throw errors.new(
-				`${label}: idb ${item.rec.name} binds ${key}, not a head column of ${item.rec.name} (head columns: ${headNames.join(", ")})`
+				`${label}: interior ${item.target.name} binds ${key}, not a head column of ${item.target.name} (head columns: ${headNames.join(", ")})`
 			)
 		}
 	}
 	for (const name of headNames) {
 		if (!keys.includes(name)) {
 			throw errors.new(
-				`${label}: idb ${item.rec.name} omits the head column ${name} — an idb join binds every head column of ${item.rec.name}`
+				`${label}: interior ${item.target.name} omits the head column ${name} — an interior join binds every head column of ${item.target.name}`
 			)
 		}
 	}
 	for (const binding of item.bindings) {
-		if (item.negated && !bound.has(binding.ref)) {
+		if (item.kind === "negatedInterior" && !bound.has(binding.ref)) {
 			throw errors.new(
-				`${label}: negated idb ${item.rec.name} names the variable ${binding.ref.label}, but no positive atom of the rule binds it — a negated atom binds nothing, only rejects (the safety rule)`
+				`${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) {
@@ -1058,7 +1014,7 @@ function validateIdb(
 		const mint = mintSlotOf(context, binding.ref)
 		if (!fieldJoins(headColumn.slot, mint)) {
 			throw errors.new(
-				`${label}: idb ${item.rec.name} joins the variable ${binding.ref.label} (${renderFieldKind(mint)}) at head column ${binding.key} (${renderFieldKind(headColumn.slot)}) — a var joins only class-equal slots; bare pairs only with bare`
+				`${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`
 			)
 		}
 	}
@@ -1067,7 +1023,7 @@ function validateIdb(
 /**
  * Completes one rule: enriches the find columns (declaration-order-safe
  * keys, boundness validated, each column's classed slot and closed slice
- * resolved), then walks the body walls — negated-atom boundness safety, idb
+ * resolved), then walks the body walls — negated-atom boundness safety, interior
  * head pairing, and condition validation.
  */
 function completeRule(context: ChainContext, state: RuleBuildState, rawColumns: readonly FindColumn[]): RuleData {
@@ -1091,8 +1047,8 @@ function completeRule(context: ChainContext, state: RuleBuildState, rawColumns:
 				}
 			}
 		}
-		if (item.kind === "idb") {
-			validateIdb(context, state.bound, item, columns)
+		if (item.kind === "interior" || item.kind === "negatedInterior") {
+			validateInterior(context, state.bound, item, columns)
 		}
 		if (item.kind === "cond") {
 			validateCond(context, state.bound, item.cond)
@@ -1113,100 +1069,116 @@ function makeRuleValue<Row, P extends ParamsRecord>(rule: RuleData): RuleValue<R
 interface RawChain {
 	match(relation: MatchOwner, bindings: Readonly<Record<string, unknown>>): RawChain
 	where(cond: AnyCond): RawChain
-	idb(target: RecRef<string, ParamsRecord>, bindings: Readonly<Record<string, unknown>>): RawChain
+	interior(name: string, bindings: Readonly<Record<string, unknown>>): RawChain
 	find(entries: Readonly<Record<string, unknown>>): RuleValue<never, never>
 }
 
 /** The runtime rule-builder shape beneath every typed scope. */
 interface RawScope extends TermOps {
 	match(relation: MatchOwner, bindings: Readonly<Record<string, unknown>>): RawChain
-	idb(target: RecRef<string, ParamsRecord>, bindings: Readonly<Record<string, unknown>>): RawChain
+	interior(name: string, bindings: Readonly<Record<string, unknown>>): RawChain
+}
+
+/** The declared derived tables a chain may name. */
+interface DerivedEnv {
+	readonly interiors: readonly InteriorData[]
+	readonly rec: RecHandle | RecHead | RecData | null
 }
 
 /** Which rule family a chain builds — plus the schema's runtime class map and theory value (the join judge's authority). */
-type ChainContext = { readonly classes: SchemaClasses; readonly theory: AnySchema } & (
-	| { readonly kind: "query" }
-	| { readonly kind: "rec"; readonly self: RecData }
-	| { readonly kind: "output"; readonly program: ProgramState }
-)
+type ChainContext = { readonly classes: SchemaClasses; readonly theory: AnySchema } & DerivedEnv &
+	(
+		| { readonly kind: "query" }
+		| { readonly kind: "interior"; readonly self: string }
+		| { readonly kind: "rec-base"; readonly self: RecHandle }
+		| { readonly kind: "rec-arm"; readonly self: RecHead }
+	)
 
 /** The diagnostic label of a chain context. */
 function contextLabel(context: ChainContext): string {
 	switch (context.kind) {
 		case "query":
 			return "query rule"
-		case "rec":
-			return `rec ${context.self.name} rule`
-		case "output":
-			return "program output rule"
+		case "interior":
+			return `interior ${context.self} rule`
+		case "rec-base":
+			return `recursive ${context.self.name} base`
+		case "rec-arm":
+			return `recursive ${context.self.name} rec`
 	}
 }
 
-/** Validates and records one `idb` atom per the context's cut. */
-function idbAdvance(
-	context: ChainContext,
-	state: RuleBuildState,
-	target: RecRef<string, ParamsRecord>,
-	bindings: Readonly<Record<string, unknown>>
-): RuleBuildState {
-	if (context.kind === "query") {
-		throw errors.new("idb is a program construct — declare recs and outputs through program(), never a plain query()")
-	}
-	if (context.kind === "rec") {
-		if (target.data !== context.self) {
+/** Resolves a derived-table name against the context's visible tables. */
+function lookupDerived(context: ChainContext, name: string): DerivedTable {
+	const interior = context.interiors.find(function byName(candidate) {
+		return candidate.name === name
+	})
+	if (interior !== undefined) {
+		if (context.kind === "interior" && name === context.self) {
 			throw errors.new(
-				`rec ${context.self.name}: a recursive rule's idb target must be the rec itself — the self-recursion-only cut (mutual recursion is unwritable; fold a finished stratum in the output rules)`
+				`interior ${name}: an interior does not read itself — declaration order is topological (a self-read is InteriorNotPrior)`
 			)
 		}
-		return advanceIdb(state, context.self, bindings, false)
+		return interior
 	}
-	if (!context.program.recs.includes(target.data)) {
-		throw errors.new(
-			`idb ${target.name}: the rec was declared by a different program — rec identity is the membership rule`
-		)
+	if (context.rec !== null && context.rec.name === name) {
+		if (context.kind === "interior") {
+			throw errors.new(`interior ${context.self}: interiors cannot read the rec — this cut's interiors are a prefix`)
+		}
+		if (context.kind === "rec-base") {
+			throw errors.new(
+				`recursive ${context.rec.name}: a base arm does not read the rec — self-atoms belong on rec arms`
+			)
+		}
+		if (!("finds" in context.rec)) {
+			throw errors.new(`recursive ${context.rec.name}: rec arms resolve the rec head after base arms seal it`)
+		}
+		return context.rec
 	}
-	return advanceIdb(state, target.data, bindings, false)
+	throw errors.new(`${contextLabel(context)}: no derived table named ${name} is in scope`)
+}
+
+/** Validates and records one interior atom per the context's cut. */
+function interiorAdvance(
+	context: ChainContext,
+	state: RuleBuildState,
+	name: string,
+	bindings: Readonly<Record<string, unknown>>
+): RuleBuildState {
+	return advanceInterior(state, lookupDerived(context, name), bindings, "interior")
 }
 
 /**
- * Validates and records one NEGATED finished-stratum atom — output rules
- * only: there every rec is a finished set before the output's operator
- * runs (negation OF lower strata is engine-legal; the strata judge refuses
- * only negation *through* a cycle, which the rec-context refusal here
- * makes unwritable).
+ * Validates and records one NEGATED finished-table atom — main and interior
+ * rules: a finished set is a set. Rec bodies refuse every negation
+ * (`NegationInRec` — self is the wall; EDB / earlier-interior is this-cut).
  */
-function notIdbAdvance(
+function notInteriorAdvance(
 	context: ChainContext,
 	state: RuleBuildState,
-	target: { readonly name: string; readonly data: RecData },
+	name: string,
 	bindings: Readonly<Record<string, unknown>>
 ): RuleBuildState {
-	if (context.kind === "query") {
-		throw errors.new("idb is a program construct — declare recs and outputs through program(), never a plain query()")
-	}
-	if (context.kind === "rec") {
+	if (context.kind === "rec-base" || context.kind === "rec-arm") {
 		throw errors.new(
-			`rec ${context.self.name}: a recursive rule negates no stratum — self-negation is negation through the cycle (a finished set is what keeps the operator monotone), and a finished stratum's fold belongs in the output rules`
+			`recursive ${context.self.name}: a recursive rule negates no table — self-negation is negation through the cycle (a finished set is what keeps the operator monotone), and a finished table's fold belongs in the main rules`
 		)
 	}
-	if (!context.program.recs.includes(target.data)) {
-		throw errors.new(
-			`idb ${target.name}: the rec was declared by a different program — rec identity is the membership rule`
-		)
-	}
-	return advanceIdb(state, target.data, bindings, true)
+	return advanceInterior(state, lookupDerived(context, name), bindings, "negatedInterior")
 }
 
-/** Classifies one find record per the context (a recursive head projects bound variables only). */
+/** Classifies one find record per the context (interior and rec heads project bound variables only). */
 function findColumns(context: ChainContext, entries: Readonly<Record<string, unknown>>): FindColumn[] {
 	const columns: FindColumn[] = []
+	const derivedHead = context.kind !== "query"
 	for (const [name, entry] of Object.entries(entries)) {
 		if (entry === undefined) {
 			continue
 		}
-		if (context.kind === "rec" && !(isTerm(entry) && entry[term] === "var")) {
+		if (derivedHead && !(isTerm(entry) && entry[term] === "var")) {
+			const who = context.kind === "interior" ? `interior ${context.self}` : `recursive ${context.self.name}`
 			throw errors.new(
-				`rec ${context.self.name}: a recursive head projects bound variables only — aggregates and the measure read finished sets (the strata judge's quarantine, unwritable here)`
+				`${who}: a recursive head projects bound variables only — aggregates and the measure read finished sets (unwritable here)`
 			)
 		}
 		columns.push(findColumnOf(name, entry))
@@ -1223,8 +1195,8 @@ function makeRawChain(context: ChainContext, state: RuleBuildState): RawChain {
 		where(cond) {
 			return makeRawChain(context, advanceWhere(context, state, cond))
 		},
-		idb(target, bindings) {
-			return makeRawChain(context, idbAdvance(context, state, target, bindings))
+		interior(name, bindings) {
+			return makeRawChain(context, interiorAdvance(context, state, name, bindings))
 		},
 		find(entries) {
 			return makeRuleValue<never, never>(completeRule(context, state, findColumns(context, entries)))
@@ -1241,8 +1213,8 @@ function makeRawScope(context: ChainContext): RawScope {
 		match(relation, bindings) {
 			return makeRawChain(context, advanceMatch(context, EMPTY_RULE, relation, bindings))
 		},
-		idb(target, bindings) {
-			return makeRawChain(context, idbAdvance(context, EMPTY_RULE, target, bindings))
+		interior(name, bindings) {
+			return makeRawChain(context, interiorAdvance(context, EMPTY_RULE, name, bindings))
 		}
 	}
 	Object.freeze(scope)
@@ -1264,32 +1236,68 @@ function isTypedScope<S>(scope: RawScope): scope is RawScope & S {
 
 /** Builds one query-rule builder (the typed face of the raw builder). */
 function makeQueryRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses>(
-	theory: AnySchema
+	theory: AnySchema,
+	env: DerivedEnv
 ): QueryRuleScope<Rels, Classes> {
-	const raw = makeRawScope({ kind: "query", classes: theory.classes, theory })
+	const raw = makeRawScope({ kind: "query", classes: theory.classes, theory, ...env })
 	if (!isTypedScope<QueryRuleScope<Rels, Classes>>(raw)) {
 		throw errors.new("query rule builder construction incomplete")
 	}
 	return raw
 }
 
-/** Builds one output-rule builder over a program's recs. */
-function makeOutputRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses>(
-	program: ProgramState
-): OutputRuleScope<Rels, Classes> {
-	const raw = makeRawScope({ kind: "output", program, classes: program.classes, theory: program.theory })
-	if (!isTypedScope<OutputRuleScope<Rels, Classes>>(raw)) {
-		throw errors.new("program output rule builder construction incomplete")
+/** Builds one interior-rule builder. */
+function makeInteriorRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses>(
+	theory: AnySchema,
+	env: DerivedEnv,
+	self: string
+): 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")
 	}
 	return raw
 }
 
-/** One program's build-time registry: its recs in declaration order, the theory value, and its class map. */
-interface ProgramState {
-	readonly recs: RecData[]
-	readonly classes: SchemaClasses
-	readonly theory: AnySchema
-	sealed: boolean
+/** Builds one rec-arm builder. */
+function makeRecRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses>(
+	theory: AnySchema,
+	env: DerivedEnv,
+	self: RecHandle,
+	kind: "rec-base"
+): RecRuleScope<Rels, Classes>
+function makeRecRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses>(
+	theory: AnySchema,
+	env: DerivedEnv,
+	self: RecHead,
+	kind: "rec-arm"
+): RecRuleScope<Rels, Classes>
+function makeRecRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses>(
+	theory: AnySchema,
+	env: DerivedEnv,
+	self: RecHandle | RecHead,
+	kind: "rec-base" | "rec-arm"
+): RecRuleScope<Rels, Classes> {
+	const raw =
+		kind === "rec-base"
+			? makeRawScope({
+					kind: "rec-base",
+					self: self as RecHandle,
+					classes: theory.classes,
+					theory,
+					...env
+				})
+			: makeRawScope({
+					kind: "rec-arm",
+					self: self as RecHead,
+					classes: theory.classes,
+					theory,
+					...env
+				})
+	if (!isTypedScope<RecRuleScope<Rels, Classes>>(raw)) {
+		throw errors.new("recursive rule builder construction incomplete")
+	}
+	return raw
 }
 
 /** Renders one head column's closed slice for the rule-alignment check's diagnostics. */
@@ -1307,9 +1315,6 @@ function headSignature(column: FindColumn): string {
 	if (agg.op === "fold") {
 		return `${column.name}:${agg.fold}`
 	}
-	if (agg.op === "arg") {
-		return `${column.name}:${agg.direction}`
-	}
 	return `${column.name}:${agg.op}`
 }
 
@@ -1324,17 +1329,22 @@ function renderParamAnchor(roster: ClosedRoster | undefined): string {
 }
 
 /**
- * Folds every rule's param uses (recs in declaration order first, output
- * rules last — exactly the lowering walk) into the query's registry: first
- * use mints the dense `ParamId`, the first FIELD-ANCHORED use types the
- * wire, and one name keeps one shape AND one closedness. The orderable
- * ban needs no registry arm: an order use always anchors its SIBLING's
- * domain (the no-variable-side spelling is refused at the comparison
- * constructor), so a closed-anchored param under an order op dies at the
- * one-domain wall here — and an order use whose sibling is itself
- * closed-bound dies at the comparison's own var-side wall first.
+ * Folds every rule's param uses (interiors in declaration order, then rec
+ * base, then rec arms, then main — exactly the lowering walk) into the
+ * query's registry: first use mints the dense `ParamId`, the first
+ * FIELD-ANCHORED use types the wire, and one name keeps one shape AND one
+ * closedness. The orderable ban needs no registry arm: an order use always
+ * anchors its SIBLING's domain (the no-variable-side spelling is refused
+ * at the comparison constructor), so a closed-anchored param under an
+ * order op dies at the one-domain wall here — and an order use whose
+ * sibling is itself closed-bound dies at the comparison's own var-side
+ * wall first.
  */
-function paramRegistryOf(recs: readonly RecData[], rules: readonly RuleData[]): readonly ParamEntry[] {
+function paramRegistryOf(
+	interiors: readonly InteriorData[],
+	rec: RecData | null,
+	rules: readonly RuleData[]
+): readonly ParamEntry[] {
 	const order: string[] = []
 	const byName = new Map<
 		string,
@@ -1383,8 +1393,16 @@ function paramRegistryOf(recs: readonly RecData[], rules: readonly RuleData[]):
 			}
 		}
 	}
-	for (const rec of recs) {
-		for (const rule of rec.rules) {
+	for (const interior of interiors) {
+		for (const rule of interior.rules) {
+			fold(rule.paramUses)
+		}
+	}
+	if (rec !== null) {
+		for (const rule of rec.base) {
+			fold(rule.paramUses)
+		}
+		for (const rule of rec.rec) {
 			fold(rule.paramUses)
 		}
 	}
@@ -1430,114 +1448,252 @@ interface RawQuery {
 	readonly schema: AnySchema
 	readonly data: QueryData
 	rule(build: (r: RawScope) => RuleValue<never, never>): RawQuery
+	interior(name: string, ...builds: never[]): never
+	recursive(name: string, arms: never): never
 }
 
-/**
- * Assembles the runtime query value over completed rules: every rule must
- * derive the SAME head (name and aggregate shape, position for position —
- * the decode labels and the engine's alignment rule agree), and the param
- * registry folds in program-walk order.
- */
-function makeRawQuery(theory: AnySchema, recs: readonly RecData[], rules: readonly RuleData[]): RawQuery {
+/** Asserts every rule in a list derives the same head (name, aggregate shape, closed slice, class). */
+function assertAlignedHeads(label: string, rules: readonly RuleData[]): void {
 	const first = rules[0]
 	if (first === undefined) {
-		throw errors.new("a query needs at least one rule")
+		throw errors.new(`${label} needs at least one rule`)
 	}
 	const signature = first.finds.map(headSignature).join(", ")
 	rules.forEach(function verifyHead(rule, index) {
 		const candidate = rule.finds.map(headSignature).join(", ")
 		if (candidate !== signature) {
 			throw errors.new(
-				`every rule of a query derives the same head — rule 0 finds (${signature}), rule ${index} finds (${candidate})`
+				`every rule of ${label} derives the same head — rule 0 finds (${signature}), rule ${index} finds (${candidate})`
 			)
 		}
-		// The closed slice is part of the head too: one answer column decodes
-		// through one roster, so a union whose rules bind a column at different
-		// vocabularies (or one closed, one bare) is refused pointed.
 		rule.finds.forEach(function verifyClosedSlice(column, position) {
 			const lead = first.finds[position]
 			if (lead !== undefined && column.closed !== lead.closed) {
 				throw errors.new(
-					`every rule of a query derives the same head — the answer column ${lead.name} is ${renderClosedSlice(lead.closed)} in rule 0 but ${renderClosedSlice(column.closed)} in rule ${index} (one column decodes through one roster)`
+					`every rule of ${label} derives the same head — the head column ${lead.name} is ${renderClosedSlice(lead.closed)} in rule 0 but ${renderClosedSlice(column.closed)} in rule ${index} (one column decodes through one roster)`
 				)
 			}
-			// The law-class wall on the union head: one answer column is one
-			// value space, so the classed mint slot each rule binds the column
-			// at must join across rules — the SAME fieldJoins judgment every
-			// join/eq/negated-atom position enforces (the SDK holds it because
-			// the wire IR carries no domains).
 			if (lead === undefined) {
 				return
 			}
 			if (lead.slot !== undefined && column.slot !== undefined && !fieldJoins(lead.slot, column.slot)) {
 				throw errors.new(
-					`every rule of a query derives the same head — the answer column ${lead.name} unions domain-unequal fields: bound at ${renderFieldKind(lead.slot)} in rule 0 but at ${renderFieldKind(column.slot)} in rule ${index} (a union column joins only class-equal slots; bare pairs only with bare)`
+					`every rule of ${label} derives the same head — the head column ${lead.name} is bound at ${renderFieldKind(lead.slot)} in rule 0 but at ${renderFieldKind(column.slot)} in rule ${index} (a head column joins only class-equal slots; bare pairs only with bare)`
 				)
 			}
 		})
 	})
+}
+
+function afterMainError(what: string): Error {
+	return errors.new(
+		`query: ${what} after a main rule is unwritable — declaration order is interiors, then rec, then main`
+	)
+}
+
+/**
+ * Assembles the runtime query value over completed rules: every rule must
+ * derive the SAME head (name and aggregate shape, position for position —
+ * the decode labels and the engine's alignment rule agree), and the param
+ * registry folds in query-walk order.
+ */
+function makeRawQuery(
+	theory: AnySchema,
+	interiors: readonly InteriorData[],
+	rec: RecData | null,
+	rules: readonly RuleData[]
+): RawQuery {
+	assertAlignedHeads("a query", rules)
+	const first = rules[0]
+	if (first === undefined) {
+		throw errors.new("a query needs at least one rule")
+	}
+	const env: DerivedEnv = { interiors, rec }
 	const data: QueryData = Object.freeze({
-		recs: Object.freeze([...recs]),
+		interiors: Object.freeze([...interiors]),
+		rec,
 		rules: Object.freeze([...rules]),
 		finds: first.finds,
-		params: paramRegistryOf(recs, rules)
+		params: paramRegistryOf(interiors, rec, rules)
 	})
 	const value: RawQuery = {
 		schema: theory,
 		data,
 		rule(build) {
-			const built = build(makeRawScope({ kind: "query", classes: theory.classes, theory }))
-			return makeRawQuery(theory, recs, [...rules, built.rule])
+			const built = build(makeRawScope({ kind: "query", classes: theory.classes, theory, ...env }))
+			return makeRawQuery(theory, interiors, rec, [...rules, built.rule])
+		},
+		interior() {
+			throw afterMainError("interior")
+		},
+		recursive() {
+			throw afterMainError("recursive")
 		}
 	}
 	Object.freeze(value)
 	return value
 }
 
-/**
- * The query values' trusted admission seam (the {@link isTypedScope} pattern):
- * the checkable fact — the value was assembled over the identical theory —
- * is verified before the raw value is admitted at its typed face.
- */
-function isQueryValue<Rels extends SchemaRelations, Row, P extends ParamsRecord, Classes extends SchemaClasses>(
-	theory: Schema<Rels, Classes>,
-	value: RawQuery
-): value is RawQuery & Query<Rels, Row, P, Classes> {
-	return value.schema === theory
-}
-
-/** Assembles one typed query value (rules already completed). */
 function makeQuery<Rels extends SchemaRelations, Row, P extends ParamsRecord, Classes extends SchemaClasses>(
 	theory: Schema<Rels, Classes>,
-	recs: readonly RecData[],
+	interiors: readonly InteriorData[],
+	rec: RecData | null,
 	rules: readonly RuleData[]
 ): Query<Rels, Row, P, Classes> {
-	const raw = makeRawQuery(theory, recs, rules)
-	if (!isQueryValue<Rels, Row, P, Classes>(theory, raw)) {
-		throw errors.new("query value construction incomplete")
+	return makeRawQuery(theory, interiors, rec, rules) as unknown as Query<Rels, Row, P, Classes>
+}
+
+/** Collects one Interior from its builders. */
+function collectInterior<Rels extends SchemaRelations, Classes extends SchemaClasses>(
+	theory: Schema<Rels, Classes>,
+	env: DerivedEnv,
+	name: string,
+	builds: readonly InteriorBuild<Rels, Classes>[]
+): InteriorData {
+	if (builds.length === 0) {
+		throw errors.new(`query: interior ${name} needs at least one rule`)
 	}
-	return raw
+	const rules = builds.map(function buildRule(buildOne) {
+		return buildOne(makeInteriorRuleScope<Rels, Classes>(theory, env, name)).rule
+	})
+	assertAlignedHeads(`interior ${name}`, rules)
+	const first = rules[0]
+	if (first === undefined) {
+		throw errors.new(`query: interior ${name} needs at least one rule`)
+	}
+	return Object.freeze({ name, finds: first.finds, rules: Object.freeze(rules) })
 }
 
-/**
- * Opens a query over a schema: `query(S).rule(r => ...)`. Each `.rule` adds
- * one conjunctive rule; multiple rules are the set union. The schema's
- * law-computed class map and theory value ride into every rule builder — the
- * join walls compare against the mint slots off it.
- */
-function query<Rels extends SchemaRelations, Classes extends SchemaClasses>(
-	theory: Schema<Rels, Classes>
-): QueryStart<Rels, Classes> {
-	const start: QueryStart<Rels, Classes> = {
+/** Collects the Rec from tagged base/rec builder arrays. */
+function collectRec<Rels extends SchemaRelations, Classes extends SchemaClasses>(
+	theory: Schema<Rels, Classes>,
+	interiors: readonly InteriorData[],
+	name: string,
+	baseBuilds: readonly RecBuild<Rels, Classes>[],
+	recBuilds: readonly RecBuild<Rels, Classes>[]
+): RecData {
+	if (baseBuilds.length === 0) {
+		throw errors.new(`query: recursive ${name} has no base arms`)
+	}
+	if (recBuilds.length === 0) {
+		throw errors.new(`query: recursive ${name} has no rec arms`)
+	}
+	const handle: RecHandle = Object.freeze({ name })
+	const baseEnv: DerivedEnv = { interiors, rec: handle }
+	const base = baseBuilds.map(function buildBase(buildOne) {
+		return buildOne(makeRecRuleScope<Rels, Classes>(theory, baseEnv, handle, "rec-base")).rule
+	})
+	assertAlignedHeads(`recursive ${name}`, base)
+	const first = base[0]
+	if (first === undefined) {
+		throw errors.new(`query: recursive ${name} has no base arms`)
+	}
+	const firstFind = first.finds[0]
+	if (firstFind === undefined) {
+		throw errors.new(`query: recursive ${name} has no head`)
+	}
+	const finds: RecHead["finds"] = [firstFind, ...first.finds.slice(1)]
+	const head: RecHead = Object.freeze({ name, finds })
+	const recEnv: DerivedEnv = { interiors, rec: head }
+	const rec = recBuilds.map(function buildRec(buildOne) {
+		return buildOne(makeRecRuleScope<Rels, Classes>(theory, recEnv, head, "rec-arm")).rule
+	})
+	assertAlignedHeads(`recursive ${name}`, [...base, ...rec])
+	const firstRec = rec[0]
+	if (firstRec === undefined) {
+		throw errors.new(`query: recursive ${name} has no rec arms`)
+	}
+	const sealedBase: RecData["base"] = [first, ...base.slice(1)]
+	const sealedRec: RecData["rec"] = [firstRec, ...rec.slice(1)]
+	const recData: RecData = Object.freeze({
+		name,
+		finds,
+		base: sealedBase,
+		rec: sealedRec
+	})
+	return recData
+}
+
+/** Builds the query start (interiors, then optional rec, then the first main rule). */
+function makeQueryStart<
+	Rels extends SchemaRelations,
+	Classes extends SchemaClasses,
+	P extends ParamsRecord,
+	Rec extends RecData | null
+>(theory: Schema<Rels, Classes>, interiors: readonly InteriorData[], rec: Rec): QueryStart<Rels, Classes, P, Rec> {
+	const env: DerivedEnv = { interiors, rec }
+	const start = {
+		interior<const Builds extends readonly InteriorBuild<Rels, Classes>[]>(
+			name: string,
+			...builds: Builds
+		): QueryStart<Rels, Classes, Flatten<P & BuildsParams<Builds>>, null> {
+			if (rec !== null) {
+				throw errors.new(
+					"query: interior after recursive is unwritable — declaration order is interiors, then rec, then main"
+				)
+			}
+			if (
+				interiors.some(function sameName(interior) {
+					return interior.name === name
+				})
+			) {
+				throw errors.new(`query: interior ${name} is already declared — names are unique`)
+			}
+			if (name.length === 0) {
+				throw errors.new("query: an interior needs a name")
+			}
+			const data = collectInterior(theory, env, name, builds)
+			return makeQueryStart<Rels, Classes, Flatten<P & BuildsParams<Builds>>, null>(theory, [...interiors, data], null)
+		},
+		recursive<
+			const Base extends readonly RecBuild<Rels, Classes>[],
+			const Step extends readonly RecBuild<Rels, Classes>[]
+		>(
+			name: string,
+			arms: { readonly base: Base; readonly rec: Step }
+		): QueryStart<Rels, Classes, Flatten<P & BuildsParams<Base> & BuildsParams<Step>>, RecData> {
+			if (rec !== null) {
+				throw errors.new("query: a second recursive is unwritable — this cut admits one linear rec")
+			}
+			if (
+				interiors.some(function sameName(interior) {
+					return interior.name === name
+				})
+			) {
+				throw errors.new(`query: interior and recursive share the name ${name}`)
+			}
+			if (name.length === 0) {
+				throw errors.new("query: recursive needs a name")
+			}
+			const data = collectRec(theory, interiors, name, arms.base, arms.rec)
+			return makeQueryStart<Rels, Classes, Flatten<P & BuildsParams<Base> & BuildsParams<Step>>, RecData>(
+				theory,
+				interiors,
+				data
+			)
+		},
 		rule<RV extends AnyRuleValue>(
 			build: (r: QueryRuleScope<Rels, Classes>) => RV
-		): Query<Rels, RowOf<RV>, ParamsOf<RV>, Classes> {
-			const built = build(makeQueryRuleScope<Rels, Classes>(theory))
-			return makeQuery<Rels, RowOf<RV>, ParamsOf<RV>, Classes>(theory, [], [built.rule])
+		): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes> {
+			const built = build(makeQueryRuleScope<Rels, Classes>(theory, env))
+			return makeQuery<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes>(theory, interiors, rec, [built.rule])
 		}
 	}
 	Object.freeze(start)
-	return start
+	return start as unknown as QueryStart<Rels, Classes, P, Rec>
+}
+
+/**
+ * Opens a query over a schema: `query(S).rule(r => ...)`, optionally with
+ * `interior` / `recursive` first. Each `.rule` adds one conjunctive rule;
+ * multiple rules are the set union. The schema's law-computed class map and
+ * theory value ride into every rule builder — the join walls compare
+ * against the mint slots off it.
+ */
+function query<Rels extends SchemaRelations, Classes extends SchemaClasses>(
+	theory: Schema<Rels, Classes>
+): QueryStart<Rels, Classes> {
+	return makeQueryStart<Rels, Classes, Record<never, never>, null>(theory, [], null)
 }
 
 /**
@@ -1670,7 +1826,7 @@ function taggedCmpLiteral(
 interface LowerContext {
 	readonly theory: AnySchema
 	readonly relationIds: ReadonlyMap<string, number>
-	readonly recIds: ReadonlyMap<RecData, number>
+	readonly interiorIds: ReadonlyMap<string, number>
 	readonly paramIds: ReadonlyMap<string, number>
 	readonly params: ReadonlyMap<string, ParamEntry>
 }
@@ -1751,35 +1907,34 @@ function lowerBindingTerm(ctx: LowerContext, context: string, binding: BindingEn
 }
 
 /**
- * Lowers one idb atom: named bindings placed by HEAD order, `FieldId(i)` =
- * head position i. Every head column of the rec must be bound (a missing key
+ * Lowers one interior atom: named bindings placed by HEAD order, `FieldId(i)` =
+ * head position i. Every head column of the table must be bound (a missing key
  * is refused pointed); the var-id assignment order is head order, so the
  * first-use numbering matches the name-keyed edition exactly.
  */
-function lowerIdbAtom(
+function lowerInteriorAtom(
 	ctx: LowerContext,
-	rec: RecData,
+	target: DerivedTable,
 	bindings: ReadonlyArray<{ readonly key: string; readonly ref: AnyVar }>,
 	ids: VarIds
 ): AtomIr {
-	const pred = ctx.recIds.get(rec)
-	if (pred === undefined) {
-		throw errors.new(`query lowering: rec ${rec.name} was declared by a different program`)
+	const interior = ctx.interiorIds.get(target.name)
+	if (interior === undefined) {
+		throw errors.new(`query lowering: derived table ${target.name} was not declared on this query`)
 	}
-	const head = rec.rules[0]
-	if (head === undefined) {
-		throw errors.new(`query lowering: rec ${rec.name} has no rules`)
+	if (target.finds.length === 0) {
+		throw errors.new(`query lowering: derived table ${target.name} has no head`)
 	}
-	const irBindings: Array<readonly [number, TermIr]> = head.finds.map(function lowerPosition(column, position) {
+	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: idb ${rec.name} omits head column ${column.name}`)
+			throw errors.new(`query lowering: interior ${target.name} omits head column ${column.name}`)
 		}
 		return [position, { kind: "var", var: ids.of(binding.ref) } as const] as const
 	})
-	return { source: { kind: "idb", pred }, bindings: irBindings }
+	return { source: { kind: "interior", interior }, bindings: irBindings }
 }
 
 /** Lowers one comparison side; literals tag by the sibling's anchor (op-aware at `pointIn`). */
@@ -1821,25 +1976,17 @@ function cmpAnchorOf(ctx: LowerContext, sibling: CmpTermData): AnyField | "measu
 
 /** Lowers one comparison. */
 function lowerComparison(ctx: LowerContext, cmp: CmpData, ids: VarIds): ComparisonIr {
-	if (cmp.op === "allen") {
-		const maskData = cmp.mask
-		if (maskData === undefined) {
-			throw errors.new("query lowering: an allen comparison lost its mask")
-		}
-		const mask =
-			maskData.kind === "literal"
-				? { kind: "literal" as const, mask: maskData.mask }
-				: { kind: "param" as const, param: paramIdOf(ctx, maskData.name) }
+	if (cmp.op.kind === "allen") {
 		return {
-			op: { kind: "allen", mask },
+			op: { kind: "allen", mask: cmp.op.mask },
 			lhs: lowerCmpTerm(ctx, cmp.lhs, cmp.rhs, ids, "allen"),
 			rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, "allen")
 		}
 	}
 	return {
-		op: { kind: cmp.op },
-		lhs: lowerCmpTerm(ctx, cmp.lhs, cmp.rhs, ids, cmp.op),
-		rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, cmp.op)
+		op: { kind: cmp.op.kind },
+		lhs: lowerCmpTerm(ctx, cmp.lhs, cmp.rhs, ids, cmp.op.kind),
+		rhs: lowerCmpTerm(ctx, cmp.rhs, cmp.lhs, ids, cmp.op.kind)
 	}
 }
 
@@ -1868,16 +2015,12 @@ function lowerFind(entry: FindEntryData, ids: VarIds): FindTermIr {
 	switch (agg.op) {
 		case "count":
 			return { kind: "aggregate", op: { kind: "count" } }
-		case "countDistinct":
-			return { kind: "aggregate", op: { kind: "countDistinct" }, over: ids.of(agg.over) }
 		case "fold": {
 			if ("duration" in agg.over) {
 				return { kind: "aggregateMeasure", op: { kind: agg.fold }, over: ids.of(agg.over.duration) }
 			}
 			return { kind: "aggregate", op: { kind: agg.fold }, over: ids.of(agg.over) }
 		}
-		case "arg":
-			return { kind: "aggregate", op: { kind: agg.direction, key: ids.of(agg.key) }, over: ids.of(agg.over) }
 		case "pack":
 			return { kind: "aggregate", op: { kind: "pack" }, over: ids.of(agg.over) }
 	}
@@ -1888,12 +2031,8 @@ function headOpOf(agg: AggData): HeadOpIr {
 	switch (agg.op) {
 		case "count":
 			return "count"
-		case "countDistinct":
-			return "countDistinct"
 		case "fold":
 			return agg.fold
-		case "arg":
-			return agg.direction
 		case "pack":
 			return "pack"
 	}
@@ -1924,9 +2063,12 @@ function lowerRule(ctx: LowerContext, rule: RuleData): RuleIr {
 				negated.push(lowerAtom(ctx, item.atom, ids))
 				break
 			}
-			case "idb": {
-				const bucket = item.negated ? negated : atoms
-				bucket.push(lowerIdbAtom(ctx, item.rec, item.bindings, ids))
+			case "interior": {
+				atoms.push(lowerInteriorAtom(ctx, item.target, item.bindings, ids))
+				break
+			}
+			case "negatedInterior": {
+				negated.push(lowerInteriorAtom(ctx, item.target, item.bindings, ids))
 				break
 			}
 			case "cond": {
@@ -1946,24 +2088,27 @@ function lowerRule(ctx: LowerContext, rule: RuleData): RuleIr {
 }
 
 /**
- * Lowers a query value to the bridge's `ProgramIr` — pure and stable: the
- * recs in declaration order (`PredId` = index), the output predicate
- * appended last. Every registered param must carry a field anchor by now.
+ * Lowers a query value to the bridge's `QueryIr` — pure and stable: interiors
+ * in declaration order, optional rec, then main. Every registered param must
+ * carry a field anchor by now.
  */
-function lowerQuery(q: AnyQuery): ProgramIr {
+function lowerQuery(q: AnyQuery): ParsedQuery {
 	const theory = q.schema
 	const relationIds = new Map<string, number>()
 	Object.keys(theory.relations).forEach(function assignOrdinal(name, index) {
 		relationIds.set(name, index)
 	})
-	const recIds = new Map<RecData, number>()
-	q.data.recs.forEach(function assignPredId(rec, index) {
-		recIds.set(rec, index)
+	const interiorIds = new Map<string, number>()
+	q.data.interiors.forEach(function assignInteriorId(interior, index) {
+		interiorIds.set(interior.name, index)
 	})
+	if (q.data.rec !== null) {
+		interiorIds.set(q.data.rec.name, q.data.interiors.length)
+	}
 	const paramIds = new Map<string, number>()
 	const params = new Map<string, ParamEntry>()
 	q.data.params.forEach(function assignParamId(entry, index) {
-		if (entry.anchor === undefined && entry.shape !== "mask") {
+		if (entry.anchor === undefined) {
 			throw errors.new(
 				`query param ${entry.name} has no field-anchored use — bind it in an atom or compare it against a bound variable`
 			)
@@ -1971,26 +2116,33 @@ function lowerQuery(q: AnyQuery): ProgramIr {
 		paramIds.set(entry.name, index)
 		params.set(entry.name, entry)
 	})
-	const ctx: LowerContext = { theory, relationIds, recIds, paramIds, params }
-	const predicates: PredicateDefIr[] = q.data.recs.map(function lowerRec(rec) {
-		const head = rec.rules[0]
-		if (head === undefined) {
-			throw errors.new(`query lowering: rec ${rec.name} has no rules`)
-		}
-		return {
-			head: head.finds.map(headTermOf),
-			rules: rec.rules.map(function lowerRecRule(rule) {
-				return lowerRule(ctx, rule)
-			})
-		}
-	})
-	predicates.push({
+	const ctx: LowerContext = { theory, relationIds, interiorIds, paramIds, params }
+	return parseQueryIr({
+		interiors: q.data.interiors.map(function lowerInterior(interior) {
+			return {
+				head: interior.finds.map(headTermOf),
+				rules: interior.rules.map(function lowerInteriorRule(rule) {
+					return lowerRule(ctx, rule)
+				})
+			}
+		}),
+		rec:
+			q.data.rec === null
+				? null
+				: {
+						head: q.data.rec.finds.map(headTermOf),
+						base: q.data.rec.base.map(function lowerBase(rule) {
+							return lowerRule(ctx, rule)
+						}),
+						rec: q.data.rec.rec.map(function lowerRecArm(rule) {
+							return lowerRule(ctx, rule)
+						})
+					},
 		head: q.data.finds.map(headTermOf),
-		rules: q.data.rules.map(function lowerOutputRule(rule) {
+		rules: q.data.rules.map(function lowerMainRule(rule) {
 			return lowerRule(ctx, rule)
 		})
 	})
-	return { predicates, output: q.data.recs.length }
 }
 
 export type {
@@ -1998,10 +2150,9 @@ export type {
 	AnyRuleValue,
 	HeadOf,
 	HeadShape,
-	OutputRuleChain,
-	OutputRuleScope,
+	InteriorRuleChain,
+	InteriorRuleScope,
 	ParamsOf,
-	ProgramState,
 	Query,
 	QueryData,
 	QueryParams,
@@ -2012,11 +2163,10 @@ export type {
 	QueryStart,
 	RawChain,
 	RawScope,
-	RecRef,
 	RecRuleChain,
 	RecRuleScope,
 	RowOf,
 	RuleValue,
 	TermOps
 }
-export { lowerQuery, makeOutputRuleScope, makeQuery, makeRawScope, query, taggedCmpLiteral, taggedLiteral }
+export { lowerQuery, makeRawScope, query, taggedCmpLiteral, taggedLiteral }