@bjornpagen/bumbledb 0.9.0 → 0.11.0

package/src/query/atom.ts

@@ -23,9 +23,9 @@
  * wall only.
  *
  * This module also owns the plain runtime DATA a built rule is made of
- * (`RuleData`/`RecData` and friends): frozen values the lowering walks —
- * pure data (variable references included), so lowering stays a pure,
- * stable function of the query value.
+ * (`RuleData`/`InteriorData`/`RecData` and friends): frozen values the
+ * lowering walks — pure data (variable references included), so lowering
+ * stays a pure, stable function of the query value.
  */
 
 import * as errors from "@superbuilders/errors"
@@ -36,23 +36,21 @@ import type {
 	ClassedField,
 	Duration,
 	JoinOk,
-	MaskParam,
 	MatchFields,
 	MatchOwner,
 	MintSlotOf,
 	Param,
-	ParamsRecord,
 	ParamValueAt,
 	SetParam,
 	ShapeOf
 } from "#query/scope.ts"
-import { inferred, isTerm } from "#query/scope.ts"
+import { isTerm, term } from "#query/scope.ts"
 import type { FieldsShape } from "#relation.ts"
 
 /**
  * One atom-binding position as runtime data. A variable rides BY REFERENCE
  * (`ref`) — object identity is the join. `literalSet` is a membership
- * ARRAY at a closed-reference field, folded into the program.
+ * ARRAY at a closed-reference field, folded into the query.
  */
 type BindingTermData =
 	| { readonly kind: "var"; readonly ref: AnyVar }
@@ -86,17 +84,15 @@ type CmpTermData =
 	| { readonly kind: "measure"; readonly ref: AnyVar }
 	| { readonly kind: "literal"; readonly value: unknown }
 
-/** The `allen` mask position as runtime data. */
-type MaskData = { readonly kind: "literal"; readonly mask: number } | { readonly kind: "param"; readonly name: string }
-
-/** One comparison condition as runtime data (`mask` present exactly for `allen`). */
-interface CmpData {
+/** One comparison condition as runtime data; the mask lives inside `allen`. */
+type CmpData = {
 	readonly kind: "cmp"
-	readonly op: CmpKind
-	readonly mask: MaskData | undefined
 	readonly lhs: CmpTermData
 	readonly rhs: CmpTermData
-}
+} & (
+	| { readonly op: { readonly kind: "allen"; readonly mask: number } }
+	| { readonly op: { readonly kind: Exclude<CmpKind, "allen"> } }
+)
 
 /** One condition-tree node as runtime data (`ir::ConditionTree`). */
 interface TreeData {
@@ -111,13 +107,11 @@ type CondData = CmpData | TreeData
 /** One aggregate's runtime description (find vocabulary, over variable REFERENCES). */
 type AggData =
 	| { readonly op: "count" }
-	| { readonly op: "countDistinct"; readonly over: AnyVar }
 	| {
 			readonly op: "fold"
 			readonly fold: "sum" | "min" | "max"
 			readonly over: AnyVar | { readonly duration: AnyVar }
 	  }
-	| { readonly op: "arg"; readonly direction: "argMax" | "argMin"; readonly over: AnyVar; readonly key: AnyVar }
 	| { readonly op: "pack"; readonly over: AnyVar }
 
 /** One classified find entry as runtime data (variables and the measure ride BY REFERENCE). */
@@ -129,12 +123,12 @@ type FindEntryData =
 /**
  * One answer column: its name (the row object key — the find record's key,
  * so renames are real and a duplicate column is unrepresentable), its entry,
- * the classed mint SLOT its values flow from (a projected var or an
- * Arg-carried payload; `undefined` for counts/folds/measures/pack, which
- * derive numbers or intervals), and — when that slot is a closed reference —
+ * the classed mint SLOT its values flow from (a projected var;
+ * `undefined` for counts/folds/measures/pack, which derive numbers or
+ * intervals), and — when that slot is a closed reference —
  * the roster the decode lifts row ids back to handle NAMES through
  * (`undefined` on every bare column). The slice is SDK-side marshaling data
- * only: the wire `ProgramIr` never carries it.
+ * only: the wire `QueryIr` never carries it.
  */
 interface FindColumn {
 	readonly name: string
@@ -144,19 +138,23 @@ interface FindColumn {
 }
 
 /**
- * One body item of a rule, in written order. The idb join is a NAMED record
- * over the rec's head keys (`key`) bound to local variables (`ref`) — the
- * typed wall a record's unordered keys would otherwise lose.
+ * One body item of a rule, in written order. An interior join is a NAMED
+ * record over the derived table's head keys (`key`) bound to local
+ * variables (`ref`) — the typed wall a record's unordered keys would
+ * otherwise lose.
  */
 type RuleItem =
 	| { readonly kind: "atom"; readonly atom: AtomData }
 	| { readonly kind: "negated"; readonly atom: AtomData }
 	| {
-			readonly kind: "idb"
-			readonly rec: RecData
+			readonly kind: "interior"
+			readonly target: DerivedTable
+			readonly bindings: ReadonlyArray<{ readonly key: string; readonly ref: AnyVar }>
+	  }
+	| {
+			readonly kind: "negatedInterior"
+			readonly target: DerivedTable
 			readonly bindings: ReadonlyArray<{ readonly key: string; readonly ref: AnyVar }>
-			/** `true` on a negated finished-stratum atom (`r.not(rec, {...})`): probed through its anti-probe, binds nothing. */
-			readonly negated: boolean
 	  }
 	| { readonly kind: "cond"; readonly cond: CondData }
 
@@ -168,7 +166,7 @@ type RuleItem =
  */
 interface ParamUse {
 	readonly name: string
-	readonly shape: "value" | "set" | "mask"
+	readonly shape: "value" | "set"
 	readonly anchor: AnyField | "measure" | undefined
 	readonly op: "binding" | CmpKind
 	readonly members: readonly string[] | undefined
@@ -181,16 +179,46 @@ interface RuleData {
 	readonly paramUses: readonly ParamUse[]
 }
 
+/** One named interior's runtime description — identity keys the dense `InteriorId` at lowering. */
+interface InteriorData {
+	readonly name: string
+	readonly finds: readonly FindColumn[]
+	readonly rules: readonly RuleData[]
+}
+
+/** A nonempty frozen list — empty base/rec/finds are unrepresentable on RecData. */
+type NonEmpty<T> = readonly [T, ...T[]]
+
 /**
- * One recursive predicate's runtime description — identity keys the dense
- * `PredId` at lowering. `rules` is appended by `rec.rule(...)` and sealed
- * (frozen) when the program's output is declared.
+ * Name-only rec identity used while base arms are in flight. Rec-base
+ * arms cannot read the rec; they must not observe a head.
  */
-interface RecData {
+interface RecHandle {
 	readonly name: string
-	readonly rules: RuleData[]
 }
 
+/**
+ * Rec identity plus the sealed head, used while rec arms are in flight
+ * and as the target those arms capture.
+ */
+interface RecHead {
+	readonly name: string
+	readonly finds: NonEmpty<FindColumn>
+}
+
+/**
+ * The optional linear rec's runtime description — identity keys the dense
+ * `InteriorId` (`interiors.length`) at lowering. Base and rec arms are
+ * nonempty by type and sealed in one assignment.
+ */
+interface RecData extends RecHead {
+	readonly base: NonEmpty<RuleData>
+	readonly rec: NonEmpty<RuleData>
+}
+
+/** A named derived table (an interior or the rec) as `.interior(name)` / `r.not(name)` resolve it. */
+type DerivedTable = InteriorData | RecHead
+
 /**
  * What a binding position of field `F` accepts: a bare structural literal
  * of the field's value type, a variable/param/∈-set-param term — and, when
@@ -286,31 +314,15 @@ interface NotAtom<R extends MatchOwner, B> {
 }
 
 /**
- * A recursive predicate as a NEGATION target — the structural half of the
- * rec reference (`data` carries rules, never fields, so an EDB or closed
- * owner can never match it and the `not()` overloads stay disjoint).
+ * One negated finished-table atom — negation OF an interior or of the
+ * finished rec is engine-legal in main (a finished set is a set), and
+ * this value is its one spelling: `r.not("reach", { c })`. Binds nothing,
+ * only rejects — every variable it names must be positively bound in the
+ * rule (the same safety rule as EDB negation).
  */
-interface RecTarget {
+interface NotInteriorAtom<B> {
+	readonly cond: "notInterior"
 	readonly name: string
-	readonly data: RecData
-	readonly [inferred]?: { readonly params: ParamsRecord; readonly head: HeadShapeOf }
-}
-
-/** The head signature a threaded rec target carries (`undefined` before its first rule seals one). */
-type HeadShapeOf = Readonly<Record<string, ClassedField>> | undefined
-
-/**
- * One negated FINISHED-STRATUM atom — negation OF a lower stratum is
- * engine-legal (the strata judge refuses only negation *through* a cycle:
- * a finished set is what keeps the operator monotone), and this value is
- * its one spelling: `r.not(reach, { c })` in an output rule rejects every
- * binding the finished stratum extends, through the engine's anti-probe.
- * Binds nothing, only rejects — every variable it names must be positively
- * bound in the rule (the same safety rule as EDB negation).
- */
-interface NotIdbAtom<Target extends RecTarget, B> {
-	readonly cond: "notIdb"
-	readonly target: Target
 	readonly bindings: B
 }
 
@@ -323,11 +335,11 @@ type AnyTreeChild = AnyCmp | Tree<readonly AnyTreeChild[]>
 /** Any negated-atom value. */
 type AnyNotAtom = NotAtom<MatchOwner, unknown>
 
-/** Any negated finished-stratum value. */
-type AnyNotIdbAtom = NotIdbAtom<RecTarget, unknown>
+/** Any negated finished-table value. */
+type AnyNotInteriorAtom = NotInteriorAtom<unknown>
 
-/** Any `.where` input: a comparison, a condition tree, or a negated atom (EDB, closed, or finished stratum). */
-type AnyCond = AnyCmp | Tree<readonly AnyTreeChild[]> | AnyNotAtom | AnyNotIdbAtom
+/** Any `.where` input: a comparison, a condition tree, or a negated atom (EDB, closed, or finished table). */
+type AnyCond = AnyCmp | Tree<readonly AnyTreeChild[]> | AnyNotAtom | AnyNotInteriorAtom
 
 /** What `eq`'s right side accepts (`ParamSet` is `Eq`-only — the IR's rule). */
 type EqRight = AnyVar | Param<string> | SetParam<string> | bigint | string | boolean | Uint8Array | IntervalValue
@@ -350,14 +362,28 @@ function comparison<Op extends CmpKind, L, R, M>(op: Op, lhs: L, rhs: R, mask: M
 }
 
 /**
- * Rejects a comparison with no term side: it is constant-valued, the
- * engine's own validation refuses it, and the lowering has no anchored
- * position to type the literals by — fail here with the same verdict.
+ * Whether a comparison side is a VARIABLE side in the engine's sense — a
+ * bound variable or the measure. A param is a constant at execution, so a
+ * comparison whose every side is a param or literal is constant-valued:
+ * the engine's `ConstantComparison` conviction
+ * (`bumbledb/crates/bumbledb/src/ir/validate/context.rs`,
+ * `comparison_shape`'s last arm).
+ */
+function isVariableSide(value: unknown): boolean {
+	return isTerm(value) && (value[term] === "var" || value[term] === "duration")
+}
+
+/**
+ * Rejects a comparison with no variable side: it is constant-valued —
+ * params included, a param is a constant the moment it binds — the
+ * engine's own validation refuses it (`ConstantComparison`), and the
+ * lowering has no anchored position to type the literals by — fail here
+ * with the same verdict.
  */
 function assertTermSide(op: string, lhs: unknown, rhs: unknown): void {
-	if (!isTerm(lhs) && !isTerm(rhs)) {
+	if (!isVariableSide(lhs) && !isVariableSide(rhs)) {
 		throw errors.new(
-			`${op}: a comparison without a variable or parameter side is constant-valued — write the query you mean`
+			`${op}: a comparison without a variable side is constant-valued (a parameter is a constant at execution) — write the query you mean`
 		)
 	}
 }
@@ -459,16 +485,15 @@ const ALLEN = Object.freeze({
 /**
  * THE interval-pair comparison (`ir::CmpOp::Allen`): two interval terms of
  * one element type, satisfied iff the pair's classification is in the
- * 13-bit mask — a literal built from the `ALLEN` constants, or a mask
- * parameter (`r.maskParam`).
+ * 13-bit mask — a literal built from the `ALLEN` constants.
  */
-function allen<const A extends IntervalSide, const M extends number | MaskParam<string>, const B extends IntervalSide>(
+function allen<const A extends IntervalSide, const B extends IntervalSide>(
 	left: A,
-	mask: M,
+	mask: number,
 	right: B
-): Cmp<"allen", A, B, M> {
+): Cmp<"allen", A, B, number> {
 	assertTermSide("allen", left, right)
-	if (typeof mask === "number" && (!Number.isInteger(mask) || mask < 0 || mask > ALLEN_ALL_BITS)) {
+	if (!Number.isInteger(mask) || mask < 0 || mask > ALLEN_ALL_BITS) {
 		throw errors.new(
 			`allen mask ${mask} is not a 13-bit mask — build masks from the ALLEN constants (bumbledb allen.rs: bits above the low 13 are unrepresentable)`
 		)
@@ -501,35 +526,25 @@ function or<const C extends readonly AnyTreeChild[]>(...children: C): Tree<C> {
  * nothing, only rejects: every variable it names must be positively bound
  * in the rule, a construction-time wall (the engine's safety refusal stands
  * behind it). A CLOSED owner is legal here too — and so is a FINISHED
- * STRATUM: `not(reach, { c })` in an output rule negates the rec's
- * finished set (a named record over its head keys, variables only — the
- * same wall `idb()` holds), the one spelling of the engine-legal
- * complement query (`(n) | Node(id: n), !reach(n);` on the Rust surface).
+ * TABLE: `not("reach", { c })` in a main rule negates the rec's finished
+ * set (a named record over its head keys, variables only), the one
+ * spelling of the engine-legal complement query.
  */
 function not<R extends MatchOwner, const B extends MatchShape<MatchFields<R>>>(relation: R, bindings: B): NotAtom<R, B>
-function not<Target extends RecTarget, const B extends Readonly<Record<string, AnyVar>>>(
-	target: Target,
+function not<const Name extends string, const B extends Readonly<Record<string, AnyVar>>>(
+	name: Name,
 	bindings: B
-): NotIdbAtom<Target, B>
+): NotInteriorAtom<B>
 function not(
-	relation: MatchOwner | RecTarget,
+	relation: MatchOwner | string,
 	bindings: Readonly<Record<string, unknown>>
-): NotAtom<MatchOwner, unknown> | NotIdbAtom<RecTarget, unknown> {
-	if (isRecTarget(relation)) {
-		return Object.freeze({ cond: "notIdb" as const, target: relation, bindings })
+): NotAtom<MatchOwner, unknown> | NotInteriorAtom<unknown> {
+	if (typeof relation === "string") {
+		return Object.freeze({ cond: "notInterior" as const, name: relation, bindings })
 	}
 	return Object.freeze({ cond: "not" as const, relation, bindings })
 }
 
-/**
- * THE negation-target discriminant: a rec's runtime data carries its rules,
- * a relation's its fields (and a closed relation's its handle roster) — the
- * shapes are disjoint by construction, so the dispatch is total.
- */
-function isRecTarget(value: MatchOwner | RecTarget): value is RecTarget {
-	return "rules" in value.data
-}
-
 /**
  * Whether a variable's OWN field is NUMERIC (u64/i64) — the judgment the
  * point side of `pointIn` and the `sum` input read: a point lives in the
@@ -560,18 +575,130 @@ type OrderVarOk<V extends AnyVar> = V["field"]["kind"] extends "bool" ? true : N
 /** Whether a variable's OWN field is interval-typed. */
 type IntervalVarOk<V extends AnyVar> = V["field"]["kind"] extends "interval" ? true : false
 
-/** One order-comparison side's judgment (off the term's own field). */
-type OrderSideOk<T> = T extends AnyVar
-	? OrderVarOk<T>
+/**
+ * Whether a comparison has a VARIABLE side (a var or the measure) — the
+ * type-level twin of the engine's `ConstantComparison` rule: a param is a
+ * constant at execution, so param-vs-param and param-vs-literal are
+ * constant-valued whatever their domains ({@link assertTermSide} is the
+ * runtime wall behind this one).
+ */
+type CmpVarSideOk<L, R> = L extends AnyVar | Duration ? true : R extends AnyVar | Duration ? true : false
+
+/**
+ * One order side's DOMAIN — the type-level twin of the engine's resolved
+ * operand type (`ir/validate/context.rs`, `classify`'s `Ord*` arms): a
+ * variable names its own field kind, the measure is u64 by definition (and
+ * never meets another measure — `DurationBothSides`), a bigint literal
+ * spans the integer domains, a param is typed by its sibling (`"open"`).
+ * `never` marks a side that is itself unorderable: interval/bytes/string
+ * vars (the operand screen), closed-bound vars (R4), a measure over a
+ * non-interval var.
+ */
+type OrderDomain<T> = T extends AnyVar
+	? OrderVarOk<T> extends true
+		? T["field"]["kind"]
+		: never
 	: T extends Duration<infer V extends AnyVar>
-		? IntervalVarOk<V>
-		: true
+		? IntervalVarOk<V> extends true
+			? "duration"
+			: never
+		: T extends Param<string>
+			? "open"
+			: T extends bigint
+				? "integer"
+				: T extends boolean
+					? "bool"
+					: never
 
-/** One point side's judgment (numeric only — a point lives in the interval's element domain, never bool). */
-type PointSideOk<T> = T extends AnyVar ? NumericVarOk<T> : true
+/**
+ * Whether two order domains may MEET under one operator — the engine's
+ * same-type rule judged pairwise, not per side: bool meets only bool (a
+ * bigint literal against a bool var is exactly `check_const`'s
+ * conviction; R3 made bool orderable, never cross-orderable), u64 and i64
+ * never meet, the measure's sibling must live in u64 (`OrdMeasureVar`:
+ * scalar ≠ U64 is `IllegalComparison`), two measures never meet, and an
+ * open side (param, integer literal) takes whatever its sibling names.
+ */
+type OrderDomainsOk<A, B> = [A] extends [never]
+	? false
+	: [B] extends [never]
+		? false
+		: A extends "open"
+			? true
+			: B extends "open"
+				? true
+				: A extends "duration"
+					? B extends "u64" | "integer"
+						? true
+						: false
+					: B extends "duration"
+						? A extends "u64" | "integer"
+							? true
+							: false
+						: A extends "bool"
+							? B extends "bool"
+								? true
+								: false
+							: B extends "bool"
+								? false
+								: A extends "integer"
+									? true
+									: B extends "integer"
+										? true
+										: A extends B
+											? true
+											: false
+
+/** The whole order comparison's judgment: a variable side exists, and the sides' domains meet. */
+type OrderPairOk<L, R> = CmpVarSideOk<L, R> extends true ? OrderDomainsOk<OrderDomain<L>, OrderDomain<R>> : false
 
-/** One interval side's judgment. */
-type IntervalSideOk<T> = T extends AnyVar ? IntervalVarOk<T> : true
+/**
+ * An interval side's ELEMENT domain: a variable names its field's element
+ * (`never` on a non-interval var), a param or bare interval literal is
+ * `"open"` — no type exists to name its element at this tier; the engine
+ * anchors it at prepare.
+ */
+type IntervalElementDomain<T> = T extends AnyVar
+	? T["field"] extends { readonly kind: "interval"; readonly element: infer E extends "u64" | "i64" }
+		? E
+		: never
+	: "open"
+
+/**
+ * The point side's domain — a point lives in the interval's element
+ * domain: a numeric var names its kind (never bool, never closed), a
+ * param or bigint literal is open.
+ */
+type PointDomain<T> = T extends AnyVar ? (NumericVarOk<T> extends true ? T["field"]["kind"] : never) : "open"
+
+/** Whether two element domains meet: both legal, and equal unless one is open. */
+type ElementMeets<A, B> = [A] extends [never]
+	? false
+	: [B] extends [never]
+		? false
+		: A extends "open"
+			? true
+			: B extends "open"
+				? true
+				: A extends B
+					? true
+					: false
+
+/**
+ * The whole `pointIn` judgment (operands already sealed interval-left):
+ * the point's domain must BE the interval's element domain — `pointIn(t,
+ * w)` with an i64-typed `t` against `interval(u64)` is the engine's
+ * `IllegalComparison`, judged here first.
+ */
+type PointInPairOk<L, R> =
+	CmpVarSideOk<L, R> extends true ? ElementMeets<IntervalElementDomain<L>, PointDomain<R>> : false
+
+/**
+ * The whole `allen` judgment: two interval sides of ONE element domain
+ * (Q1 — widths meet freely, u64-vs-i64 stays illegal), judged pairwise.
+ */
+type AllenPairOk<L, R> =
+	CmpVarSideOk<L, R> extends true ? ElementMeets<IntervalElementDomain<L>, IntervalElementDomain<R>> : false
 
 /** The `eq`/`ne` judgment: var-var joins by mint slot; var-literal is exact-typed by the var's own field. */
 type EqOk<Classes extends SchemaClasses, L, R> = L extends AnyVar
@@ -600,55 +727,25 @@ type NotOk<Classes extends SchemaClasses, F extends FieldsShape, CR, B> = false
 	? false
 	: true
 
-/** Reads a rec target's sealed head signature off its inference slot (`undefined` on an unthreaded handle). */
-type RecHeadOf<T> = T extends { readonly [inferred]?: infer S }
-	? Exclude<S, undefined> extends { readonly head: infer H }
-		? H
-		: undefined
-	: undefined
-
-/** Reads a rec target's params record off its inference slot. */
-type RecParamsOf<T> = T extends { readonly [inferred]?: infer S }
-	? Exclude<S, undefined> extends { readonly params: infer P }
-		? P
-		: never
-	: never
-
-/** One negated finished-stratum position's judgment: a variable, class-equal to its head slot when the head is carried. */
-type NotIdbBindingOk<Classes extends SchemaClasses, HeadSlot, V> = V extends AnyVar
-	? HeadSlot extends ClassedField
-		? JoinOk<HeadSlot, MintSlotOf<Classes, V>> extends true
-			? true
-			: false
-		: true
-	: false
+/** One negated finished-table position's judgment: a variable. */
+type NotInteriorBindingOk<V> = V extends AnyVar ? true : false
 
 /**
- * The whole negated finished-stratum atom's judgment — the negation twin of
- * the `idb()` chain's `CheckIdbBindings`: when the target carries its head
- * (a threaded rec handle), the bindings record's key set must EXACTLY equal
- * the head's and each variable must be class-equal to its head slot; an
- * unthreaded handle still takes variables only.
+ * The whole negated finished-table atom's judgment — variables only;
+ * 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).
  */
-type NotIdbOk<Classes extends SchemaClasses, Head, B> =
-	Head extends Readonly<Record<string, ClassedField>>
-		? [keyof B] extends [keyof Head]
-			? [keyof Head] extends [keyof B]
-				? false extends { [K in keyof B]: NotIdbBindingOk<Classes, Head[K & keyof Head], B[K]> }[keyof B]
-					? false
-					: true
-				: false
-			: false
-		: false extends { [K in keyof B]: B[K] extends AnyVar ? true : false }[keyof B]
-			? false
-			: true
+type NotInteriorOk<B> = false extends { [K in keyof B]: NotInteriorBindingOk<B[K]> }[keyof B] ? false : true
 
 /**
  * One condition's judgment — the type-level twin of the engine's comparison
- * roster: class-equal joins (off the mint slots), orderable order sides (an
- * interval var under a non-`pointIn` op is exactly here refused),
- * kind-correct `pointIn`/`allen` sides, and negated-atom class safety. The
- * leading `[AnyTreeChild] extends [C]` arm is the recursion's base case.
+ * roster: class-equal joins (off the mint slots), PAIRWISE-judged order
+ * domains (an interval var under a non-`pointIn` op is refused per side;
+ * bool-vs-numeric, u64-vs-i64, and measure-vs-non-u64 are refused as
+ * pairs — the engine's same-type rule), element-matched `pointIn`/`allen`
+ * pairs, the no-variable-side (constant comparison) rule, and
+ * negated-atom class safety. The leading `[AnyTreeChild] extends [C]` arm
+ * is the recursion's base case.
  */
 type CondOkBool<Classes extends SchemaClasses, C> = [AnyTreeChild] extends [C]
 	? true
@@ -656,24 +753,18 @@ type CondOkBool<Classes extends SchemaClasses, C> = [AnyTreeChild] extends [C]
 		? Op extends "eq" | "ne"
 			? EqOk<Classes, L, R>
 			: Op extends "lt" | "le" | "gt" | "ge"
-				? [OrderSideOk<L>, OrderSideOk<R>] extends [true, true]
-					? true
-					: false
+				? OrderPairOk<L, R>
 				: Op extends "pointIn"
-					? [IntervalSideOk<L>, PointSideOk<R>] extends [true, true]
-						? true
-						: false
+					? PointInPairOk<L, R>
 					: Op extends "allen"
-						? [IntervalSideOk<L>, IntervalSideOk<R>] extends [true, true]
-							? true
-							: false
+						? AllenPairOk<L, R>
 						: false
 		: C extends Tree<infer Ch extends readonly AnyTreeChild[]>
 			? false extends CondOkBool<Classes, Ch[number]>
 				? false
 				: true
-			: C extends NotIdbAtom<infer T extends RecTarget, infer B>
-				? NotIdbOk<Classes, RecHeadOf<T>, B>
+			: C extends NotInteriorAtom<infer B>
+				? NotInteriorOk<B>
 				: C extends NotAtom<infer R extends MatchOwner, infer B>
 					? NotOk<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 					: false
@@ -706,9 +797,6 @@ type PointParams<T> = T extends Param<infer P extends string> ? { readonly [Q in
 /** An interval side's params contribution. */
 type IntervalSideParams<T> = T extends Param<infer P extends string> ? { readonly [Q in P]: IntervalValue } : never
 
-/** The mask position's params contribution. */
-type MaskParams<M> = M extends MaskParam<infer P extends string> ? { readonly [Q in P]: number } : never
-
 /**
  * One condition's params-object fragments (a union; the rule builder folds
  * them into the inferred `Params` record) — every param typed by its use.
@@ -716,7 +804,7 @@ type MaskParams<M> = M extends MaskParam<infer P extends string> ? { readonly [Q
  */
 type CondParams<C> = [AnyTreeChild] extends [C]
 	? never
-	: C extends Cmp<infer Op, infer L, infer R, infer M>
+	: C extends Cmp<infer Op, infer L, infer R, infer _M>
 		? Op extends "eq" | "ne"
 			? EqParams<L, R>
 			: Op extends "lt" | "le" | "gt" | "ge"
@@ -724,12 +812,12 @@ type CondParams<C> = [AnyTreeChild] extends [C]
 				: Op extends "pointIn"
 					? IntervalSideParams<L> | PointParams<R>
 					: Op extends "allen"
-						? IntervalSideParams<L> | IntervalSideParams<R> | MaskParams<M>
+						? IntervalSideParams<L> | IntervalSideParams<R>
 						: never
 		: C extends Tree<infer Ch extends readonly AnyTreeChild[]>
 			? CondParams<Ch[number]>
-			: C extends NotIdbAtom<infer T extends RecTarget, unknown>
-				? RecParamsOf<T>
+			: C extends NotInteriorAtom<unknown>
+				? never
 				: C extends NotAtom<infer R extends MatchOwner, infer B>
 					? BindParams<MatchFields<R>, B>
 					: never
@@ -762,23 +850,25 @@ export type {
 	CondOkBool,
 	CondParams,
 	CondParamsShape,
+	DerivedTable,
 	FindColumn,
 	FindEntryData,
+	InteriorData,
 	IntervalSide,
 	IntervalVarOk,
-	MaskData,
 	MatchFields,
 	MatchOwner,
 	MatchShape,
 	NotAtom,
-	NotIdbAtom,
+	NotInteriorAtom,
 	NumericVarOk,
 	OrderSide,
 	OrderVarOk,
 	ParamUse,
 	PointSide,
 	RecData,
-	RecTarget,
+	RecHandle,
+	RecHead,
 	RuleData,
 	RuleItem,
 	SlotAt,