@bjornpagen/bumbledb 0.15.0 → 0.17.0

package/src/query/atom.ts

@@ -1,40 +1,9 @@
-/**
- * Atoms and conditions, REFERENCE-IDENTITY edition — the body vocabulary of
- * a rule, mirroring the engine IR variant for variant
- * (`bumbledb/crates/bumbledb/src/ir.rs`, the bijection target;
- * `docs/architecture/20-query-ir.md` normative). A `match` binding record
- * binds fields to VARIABLES (minted by {@link v}), params, ∈-set params, or
- * bare structural literals — a closed-reference field's literal is its
- * handle NAME, and a plain ARRAY of names there is membership
- * (unmentioned fields ARE the wildcard — no wildcard value exists);
- * `not(Rel, {...})` is negation-as-position (anti-join); `eq`/`ne` and the
- * order roster, `pointIn` (the one spelling of `ir::CmpOp::PointIn`,
- * always lowered interval-left), `allen` (the 13-bit mask pair
- * comparison), and `and`/`or` (the input condition-tree grammar) complete
- * the roster. Nothing beyond the IR exists here — and the walls the engine
- * enforces at prepare are TYPES first: a variable joins only class-equal
- * fields, judged at every binding position against the var's MINT slot
- * ({@link MintSlotOf}); because {@link JoinOk} is an equality, that ALONE
- * makes every cross-binding join transitively class-equal (the env/sibling
- * checks the name-keyed edition needed are gone). An interval-typed var
- * under a non-`pointIn` comparison is unwritable. BOUNDNESS (a negated
- * atom's variables must be positively bound) is the one check types cannot
- * carry — object identity is invisible to TS — so it is a construction-time
- * wall only.
- *
- * This module also owns the plain runtime DATA a built rule is made of
- * (`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"
 import type { AnyField, ClosedIdField, ClosedRoster, Infer, IntervalValue } from "#fields.ts"
 import type { ClassLookup, ClassRecordOf, SchemaClasses } from "#law.ts"
 import type {
 	AnyVar,
 	ClassedField,
-	Duration,
 	JoinOk,
 	MatchFields,
 	MatchOwner,
@@ -47,11 +16,6 @@ import type {
 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 query.
- */
 type BindingTermData =
 	| { readonly kind: "var"; readonly ref: AnyVar }
 	| { readonly kind: "param"; readonly name: string }
@@ -59,7 +23,6 @@ type BindingTermData =
 	| { readonly kind: "literalSet"; readonly name: string; readonly members: readonly string[] }
 	| { readonly kind: "literal"; readonly value: unknown }
 
-/** One resolved binding: the field's name, its descriptor, its law-computed class, and the term. */
 interface BindingEntry {
 	readonly field: string
 	readonly data: AnyField
@@ -67,24 +30,19 @@ interface BindingEntry {
 	readonly term: BindingTermData
 }
 
-/** One EDB atom as runtime data (either polarity — polarity is the rule item's; a closed owner is a ψ atom). */
 interface AtomData {
 	readonly relation: MatchOwner
 	readonly bindings: readonly BindingEntry[]
 }
 
-/** One comparison operator name (mirrors `ir::CmpOp`). */
 type CmpKind = "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "pointIn" | "allen"
 
-/** One comparison side as runtime data (variables and the measure ride BY REFERENCE). */
 type CmpTermData =
 	| { readonly kind: "var"; readonly ref: AnyVar }
 	| { readonly kind: "param"; readonly name: string }
 	| { readonly kind: "setParam"; readonly name: string }
-	| { readonly kind: "measure"; readonly ref: AnyVar }
 	| { readonly kind: "literal"; readonly value: unknown }
 
-/** One comparison condition as runtime data; the mask lives inside `allen`. */
 type CmpData = {
 	readonly kind: "cmp"
 	readonly lhs: CmpTermData
@@ -94,42 +52,27 @@ type CmpData = {
 	| { readonly op: { readonly kind: Exclude<CmpKind, "allen"> } }
 )
 
-/** One condition-tree node as runtime data (`ir::ConditionTree`). */
 interface TreeData {
 	readonly kind: "tree"
 	readonly op: "and" | "or"
 	readonly children: readonly CondData[]
 }
 
-/** Any condition node as runtime data. */
 type CondData = CmpData | TreeData
 
-/** One aggregate's runtime description (find vocabulary, over variable REFERENCES). */
 type AggData =
 	| { readonly op: "count" }
 	| {
 			readonly op: "fold"
 			readonly fold: "sum" | "min" | "max"
-			readonly over: AnyVar | { readonly duration: AnyVar }
+			readonly over: AnyVar
 	  }
 	| { readonly op: "pack"; readonly over: AnyVar }
 
-/** One classified find entry as runtime data (variables and the measure ride BY REFERENCE). */
 type FindEntryData =
 	| { readonly kind: "var"; readonly over: AnyVar }
-	| { readonly kind: "measure"; readonly over: AnyVar }
 	| { readonly kind: "aggregate"; readonly agg: AggData }
 
-/**
- * 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;
- * `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 `QueryIr` never carries it.
- */
 interface FindColumn {
 	readonly name: string
 	readonly entry: FindEntryData
@@ -137,12 +80,6 @@ interface FindColumn {
 	readonly slot: ClassedField | undefined
 }
 
-/**
- * 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 }
@@ -158,35 +95,26 @@ type RuleItem =
 	  }
 	| { readonly kind: "cond"; readonly cond: CondData }
 
-/**
- * One use of a parameter inside a rule, in written order: the census the
- * query-level registry folds (first use mints the dense `ParamId`, first
- * FIELD-ANCHORED use types the wire). `members` is present exactly on a
- * membership-array use.
- */
 interface ParamUse {
 	readonly name: string
 	readonly shape: "value" | "set"
-	readonly anchor: AnyField | "measure" | undefined
+	readonly anchor: AnyField | undefined
 	readonly op: "binding" | CmpKind
 	readonly members: readonly string[] | undefined
 }
 
-/** One complete rule as runtime data. */
 interface RuleData {
 	readonly items: readonly RuleItem[]
 	readonly finds: readonly FindColumn[]
 	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[]]
 
 /**
@@ -197,34 +125,18 @@ interface RecHandle {
 	readonly name: string
 }
 
-/**
- * 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 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
- * the field is interval-typed, a bare point literal. A CLOSED-reference
- * field additionally takes a plain ARRAY of handle names read as membership.
- */
 type BindingInput<F extends AnyField> =
 	| Infer<F>
 	| (F extends ClosedIdField ? readonly Infer<F>[] : never)
@@ -233,33 +145,15 @@ type BindingInput<F extends AnyField> =
 	| Param<string>
 	| SetParam<string>
 
-/**
- * The `match`/`not` bindings record: per field, a term or literal of that
- * field's structural type; unmentioned fields are wildcards (absence IS
- * the wildcard — the IR has no wildcard variant to spell).
- */
 type MatchShape<F extends FieldsShape> = {
 	readonly [K in keyof F]?: BindingInput<F[K]>
 }
 
-/**
- * One field position of a bindings record as a classed slot: the declared
- * descriptor plus the slot's law-computed class, read off the relation's
- * class record (`CR`). The one shape a binding position's join judgment
- * compares against.
- */
 type SlotAt<F extends FieldsShape, CR, K> = {
 	readonly field: F[K & keyof F]
 	readonly class: ClassLookup<CR, K>
 }
 
-/**
- * The per-property join judgment of a bindings record: a VARIABLE binding
- * must join its own MINT slot to the position slot (a cross-class reuse maps
- * the property to `never`). Because {@link JoinOk} is an equality, judging
- * every position against the mint slot makes all cross-binding joins
- * mutually class-equal by transitivity — no env or sibling arm is needed.
- */
 type CheckBindings<Classes extends SchemaClasses, F extends FieldsShape, CR, B> = {
 	readonly [K in keyof B]: K extends keyof F
 		? B[K] extends AnyVar
@@ -270,7 +164,6 @@ type CheckBindings<Classes extends SchemaClasses, F extends FieldsShape, CR, B>
 		: never
 }
 
-/** The params-object fragments a bindings record contributes (one union member per param use). */
 type BindParams<F extends FieldsShape, B> = {
 	[K in keyof B & keyof F]: B[K] extends Param<infer P extends string>
 		? { readonly [Q in P]: ParamValueAt<F[K]> }
@@ -279,12 +172,6 @@ type BindParams<F extends FieldsShape, B> = {
 			: never
 }[keyof B & keyof F]
 
-/**
- * One comparison VALUE: op plus its operands, raw — the runtime
- * representation carries the operands (variable references included), so
- * `.where`'s judgment and the params inference both read the value itself.
- * `mask` is populated exactly for `allen`.
- */
 interface Cmp<Op extends CmpKind, L, R, M = undefined> {
 	readonly cond: "cmp"
 	readonly op: Op
@@ -293,7 +180,6 @@ interface Cmp<Op extends CmpKind, L, R, M = undefined> {
 	readonly mask: M
 }
 
-/** One condition-tree VALUE (`and`/`or` over comparisons and nested trees). */
 interface Tree<Ch extends readonly AnyTreeChild[]> {
 	readonly cond: "tree"
 	readonly op: "and" | "or"
@@ -313,73 +199,40 @@ interface NotAtom<R extends MatchOwner, B> {
 	readonly bindings: B
 }
 
-/**
- * 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 NotInteriorAtom<B> {
 	readonly cond: "notInterior"
 	readonly name: string
 	readonly bindings: B
 }
 
-/** Any comparison value. */
 type AnyCmp = Cmp<CmpKind, unknown, unknown, unknown>
 
-/** Any condition-tree child (trees hold comparisons and trees — never atoms). */
 type AnyTreeChild = AnyCmp | Tree<readonly AnyTreeChild[]>
 
-/** Any negated-atom value. */
 type AnyNotAtom = NotAtom<MatchOwner, 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 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
 
-/** What `ne`'s right side accepts. */
 type NeRight = AnyVar | Param<string> | bigint | string | boolean | Uint8Array | IntervalValue
 
-/** One side of an order comparison: orderable terms only (the IR's comparison rules — bool orders, `false < true`, R3). */
-type OrderSide = AnyVar | Param<string> | Duration | bigint | boolean
+type OrderSide = AnyVar | Param<string> | bigint | boolean
 
-/** The point side of `pointIn`. */
 type PointSide = AnyVar | Param<string> | bigint
 
-/** The interval side of `pointIn`/`allen`. */
 type IntervalSide = AnyVar | Param<string> | IntervalValue
 
-/** Builds one comparison value. */
 function comparison<Op extends CmpKind, L, R, M>(op: Op, lhs: L, rhs: R, mask: M): Cmp<Op, L, R, M> {
 	return Object.freeze({ cond: "cmp", op, lhs, rhs, mask })
 }
 
-/**
- * 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")
+	return isTerm(value) && value[term] === "var"
 }
 
-/**
- * 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 (!isVariableSide(lhs) && !isVariableSide(rhs)) {
 		throw errors.new(
@@ -388,23 +241,14 @@ function assertTermSide(op: string, lhs: unknown, rhs: unknown): void {
 	}
 }
 
-/**
- * The equality comparison (`ir::CmpOp::Eq`) — a bound variable against a
- * variable (var-to-var unification, class-equal by the join judgment), a
- * param (typed by the variable), an ∈-set param (`Eq`-only), or a bare
- * literal of the variable's own value type. Prefer direct placement in
- * `match` where punning applies.
- */
 function eq<L extends AnyVar, const R extends EqRight>(left: L, right: R): Cmp<"eq", L, R> {
 	return comparison("eq", left, right, undefined)
 }
 
-/** Typed disequality (`ir::CmpOp::Ne`). "Not in set" has no operator — write a negated atom. */
 function ne<L extends AnyVar, const R extends NeRight>(left: L, right: R): Cmp<"ne", L, R> {
 	return comparison("ne", left, right, undefined)
 }
 
-/** The shared order-comparison constructor. */
 function order<Op extends "lt" | "le" | "gt" | "ge", const L extends OrderSide, const R extends OrderSide>(
 	op: Op,
 	left: L,
@@ -414,50 +258,29 @@ function order<Op extends "lt" | "le" | "gt" | "ge", const L extends OrderSide,
 	return comparison(op, left, right, undefined)
 }
 
-/** Strict less-than (`ir::CmpOp::Lt`) — orderable sides only (bool included: `false < true`, R3), never intervals/bytes/strings. */
 function lt<const L extends OrderSide, const R extends OrderSide>(left: L, right: R): Cmp<"lt", L, R> {
 	return order("lt", left, right)
 }
 
-/** Less-or-equal (`ir::CmpOp::Le`). */
 function le<const L extends OrderSide, const R extends OrderSide>(left: L, right: R): Cmp<"le", L, R> {
 	return order("le", left, right)
 }
 
-/** Strict greater-than (`ir::CmpOp::Gt`). */
 function gt<const L extends OrderSide, const R extends OrderSide>(left: L, right: R): Cmp<"gt", L, R> {
 	return order("gt", left, right)
 }
 
-/** Greater-or-equal (`ir::CmpOp::Ge`). */
 function ge<const L extends OrderSide, const R extends OrderSide>(left: L, right: R): Cmp<"ge", L, R> {
 	return order("ge", left, right)
 }
 
-/**
- * Point membership as a predicate (`ir::CmpOp::PointIn`) — THE one
- * spelling: `pointIn(t, w)` holds iff `w.start ≤ t < w.end`. The IR
- * orders the operands interval-left, point-right; the value stores them
- * that way whatever the surface argument order. Interval ⊇ interval is NOT
- * this operator; that predicate is `allen(a, ALLEN.covers, b)`.
- */
 function pointIn<const P extends PointSide, const I extends IntervalSide>(point: P, interval: I): Cmp<"pointIn", I, P> {
 	assertTermSide("pointIn", point, interval)
 	return comparison("pointIn", interval, point, undefined)
 }
 
-/**
- * The 13-bit mask range: bits above the low 13 are unrepresentable in the
- * engine's `AllenMask` (`bumbledb/crates/bumbledb/src/allen.rs`:
- * `AllenMask::new` refuses them).
- */
 const ALLEN_ALL_BITS = (1 << 13) - 1
 
-/**
- * The Allen coordinate system's named constants — the 13 basics in the
- * engine's palindromic bit order plus the workload composites, values
- * identical to the engine's. Compose with `|`: `ALLEN.before | ALLEN.meets`.
- */
 const ALLEN = Object.freeze({
 	before: 1 << 0,
 	meets: 1 << 1,
@@ -472,21 +295,16 @@ const ALLEN = Object.freeze({
 	overlappedBy: 1 << 10,
 	metBy: 1 << 11,
 	after: 1 << 12,
-	/** The point-sets share a point (9 bits; under half-open intervals *meets* shares none). */
+
 	intersects: (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7) | (1 << 8) | (1 << 9) | (1 << 10),
-	/** Point-set ⊇: equals ∪ contains ∪ started-by ∪ finished-by. */
+
 	covers: (1 << 6) | (1 << 8) | (1 << 9) | (1 << 7),
-	/** Point-set ⊆ — `covers`' converse: equals ∪ during ∪ starts ∪ finishes. */
+
 	coveredBy: (1 << 6) | (1 << 4) | (1 << 3) | (1 << 5),
-	/** The point-sets share no point: before ∪ meets ∪ met-by ∪ after. */
+
 	disjoint: (1 << 0) | (1 << 1) | (1 << 11) | (1 << 12)
 })
 
-/**
- * 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.
- */
 function allen<const A extends IntervalSide, const B extends IntervalSide>(
 	left: A,
 	mask: number,
@@ -501,27 +319,16 @@ function allen<const A extends IntervalSide, const B extends IntervalSide>(
 	return comparison("allen", left, right, mask)
 }
 
-/**
- * Conjunction node of the input condition grammar (`ConditionTree::And`).
- * The rule's condition list is already a conjunction — `and` exists for
- * nesting under `or`, and the empty combination keeps the IR's algebraic
- * reading (`And([])` is true).
- */
 function and<const C extends readonly AnyTreeChild[]>(...children: C): Tree<C> {
 	return Object.freeze({ cond: "tree", op: "and", children: Object.freeze(children) })
 }
 
-/**
- * Disjunction node of the input condition grammar (`ConditionTree::Or`) —
- * the one place the surface admits a nested OR; validation distributes it
- * to DNF rules engine-side. `Or([])` keeps its algebraic reading (false).
- */
 function or<const C extends readonly AnyTreeChild[]>(...children: C): Tree<C> {
 	return Object.freeze({ cond: "tree", op: "or", children: Object.freeze(children) })
 }
 
 /**
- * Negation — anti-join over sets: `not(Rel, { field: someVar, ... })`
+ * Negation — anti-join over sets: `not(Rel, { field: someVar,... })`
  * rejects every binding some matching fact extends. A negated atom binds
  * nothing, only rejects: every variable it names must be positively bound
  * in the rule, a construction-time wall (the engine's safety refusal stands
@@ -551,7 +358,7 @@ function not(
  * interval's element domain, and a quantifier is not an addition, so bool
  * (orderable, never numeric) is exactly here refused. A CLOSED reference
  * is excluded even though its kind is `u64`: a vocabulary's declaration-id
- * order is an accident, not semantics (`docs/architecture/10-data-model.md`
+ * order is an accident, not semantics
  * § orderability), so every order-comparison and fold position refuses
  * closed-bound terms — the construction-time validations in
  * `#query/lower.ts` are that ban's runtime twin.
@@ -562,63 +369,24 @@ type NumericVarOk<V extends AnyVar> = V["field"] extends { readonly closed: Clos
 		? true
 		: false
 
-/**
- * Whether a variable's OWN field is ORDERABLE (u64/i64/bool) — the one gate
- * every order-comparison side, `min`/`max` input, and Arg key reads. Bool
- * orders: `false < true`, the strict 0/1 encoding IS the order (ruled R3),
- * exactly the engine's operand screen
- * (`bumbledb/crates/bumbledb/src/ir/validate/context.rs`); bool has no
- * closed variant, so the closed exclusion rides in {@link NumericVarOk}.
- */
 type OrderVarOk<V extends AnyVar> = V["field"]["kind"] extends "bool" ? true : NumericVarOk<V>
 
-/** Whether a variable's OWN field is interval-typed. */
 type IntervalVarOk<V extends AnyVar> = V["field"]["kind"] extends "interval" ? true : false
 
-/**
- * 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
+type CmpVarSideOk<L, R> = L extends AnyVar ? true : R extends AnyVar ? 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> extends true
-			? "duration"
-			: never
-		: T extends Param<string>
-			? "open"
-			: T extends bigint
-				? "integer"
-				: T extends boolean
-					? "bool"
-					: never
+	: T extends Param<string>
+		? "open"
+		: T extends bigint
+			? "integer"
+			: T extends boolean
+				? "bool"
+				: never
 
-/**
- * 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]
@@ -627,51 +395,30 @@ type OrderDomainsOk<A, B> = [A] extends [never]
 			? true
 			: B extends "open"
 				? true
-				: A extends "duration"
-					? B extends "u64" | "integer"
+				: A extends "bool"
+					? B extends "bool"
 						? true
 						: false
-					: B extends "duration"
-						? A extends "u64" | "integer"
+					: B extends "bool"
+						? false
+						: A extends "integer"
 							? true
-							: false
-						: A extends "bool"
-							? B extends "bool"
+							: B extends "integer"
 								? true
-								: false
-							: B extends "bool"
-								? false
-								: A extends "integer"
+								: A extends B
 									? true
-									: B extends "integer"
-										? true
-										: A extends B
-											? true
-											: false
+									: 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
 
-/**
- * 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]
@@ -684,23 +431,12 @@ type ElementMeets<A, B> = [A] extends [never]
 					? 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
 	? R extends AnyVar
 		? JoinOk<MintSlotOf<Classes, L>, MintSlotOf<Classes, R>> extends true
@@ -713,28 +449,20 @@ type EqOk<Classes extends SchemaClasses, L, R> = L extends AnyVar
 				: false
 	: false
 
-/** One negated-atom binding's judgment: a variable must be class-equal (boundness is a runtime wall). */
 type NotBindingOk<Classes extends SchemaClasses, S extends ClassedField, T> = T extends AnyVar
 	? JoinOk<MintSlotOf<Classes, T>, S> extends true
 		? true
 		: false
 	: true
 
-/** The whole negated atom's judgment (`CR` — the negated relation's class record off the schema class map). */
 type NotOk<Classes extends SchemaClasses, F extends FieldsShape, CR, B> = false extends {
 	[K in keyof B]: NotBindingOk<Classes, SlotAt<F, CR, K>, B[K]>
 }[keyof B]
 	? false
 	: true
 
-/** One negated finished-table position's judgment: a variable. */
 type NotInteriorBindingOk<V> = V extends AnyVar ? true : false
 
-/**
- * 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 NotInteriorOk<B> = false extends { [K in keyof B]: NotInteriorBindingOk<B[K]> }[keyof B] ? false : true
 
 /**
@@ -769,10 +497,8 @@ type CondOkBool<Classes extends SchemaClasses, C> = [AnyTreeChild] extends [C]
 					? NotOk<Classes, MatchFields<R>, ClassRecordOf<Classes, R["name"]>, B>
 					: false
 
-/** The validated `.where` argument (intersect with the inferred condition type). */
 type CheckCond<Classes extends SchemaClasses, C> = CondOkBool<Classes, C> extends true ? C : never
 
-/** The `eq`/`ne` params contribution: the param typed by the left variable's own field. */
 type EqParams<L, R> = L extends AnyVar
 	? R extends Param<infer P extends string>
 		? { readonly [Q in P]: Infer<L["field"]> }
@@ -781,27 +507,15 @@ type EqParams<L, R> = L extends AnyVar
 			: never
 	: never
 
-/**
- * An order side's params contribution, typed by the SIBLING side — the
- * runtime anchors a param to its sibling variable's field, so a bool var
- * orders against a `boolean` param; every var-less pairing stays `bigint`.
- */
 type OrderSideParams<T, Sib> =
 	T extends Param<infer P extends string>
 		? { readonly [Q in P]: Sib extends AnyVar ? Infer<Sib["field"]> : bigint }
 		: never
 
-/** The point side's params contribution (a point is always `bigint`). */
 type PointParams<T> = T extends Param<infer P extends string> ? { readonly [Q in P]: bigint } : never
 
-/** An interval side's params contribution. */
 type IntervalSideParams<T> = T extends Param<infer P extends string> ? { readonly [Q in P]: IntervalValue } : 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.
- * The leading arm is the same base case as {@link CondOkBool}'s.
- */
 type CondParams<C> = [AnyTreeChild] extends [C]
 	? never
 	: C extends Cmp<infer Op, infer L, infer R, infer _M>
@@ -863,7 +577,6 @@ export type {
 	NotInteriorAtom,
 	NumericVarOk,
 	OrderSide,
-	OrderVarOk,
 	ParamUse,
 	PointSide,
 	RecData,