@bjornpagen/bumbledb 0.8.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bjornpagen/bumbledb",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Type-theoretic TypeScript SDK for the bumbledb embedded relational engine",
   "type": "module",
   "exports": {
@@ -40,9 +40,6 @@
   "dependencies": {
     "@superbuilders/errors": "^4.0.2"
   },
-  "optionalDependencies": {
-    "@bjornpagen/bumbledb-darwin-arm64": "0.8.0"
-  },
   "devDependencies": {
     "@biomejs/biome": "^2.0.0-beta.5",
     "@types/node": "^26.1.0",
@@ -55,6 +52,9 @@
     "access": "public"
   },
   "private": false,
+  "optionalDependencies": {
+    "@bjornpagen/bumbledb-darwin-arm64": "0.10.0"
+  },
   "scripts": {
     "build": "node scripts/build.ts",
     "typecheck": "tsc --noEmit",

package/src/capacity.ts

@@ -196,6 +196,20 @@ type UnitWindowBan<W extends CapacityWindow> = W["window"] extends {
 	? BannedWindow<"`{1..*}` on the unit instance says only what the bare containment says — write contained(source, target)">
 	: unknown
 
+/**
+ * The C18 dimension gate's ban row, unit instance (the engine's
+ * `CapacityDimensionMixing` twin, ruled 2026-07-24): a unit (count)
+ * window against a `duration()` bound counts facts against a span of
+ * time — a dimension error. Judged on the `capacity()` UNIT overload
+ * only: Duration weights pair with Duration-capable bounds, so the
+ * weighted overload takes the same window freely.
+ */
+type UnitDimensionBan<W extends CapacityWindow> = W["window"] extends {
+	readonly hi: { readonly kind: "durationField" }
+}
+	? BannedWindow<"a count of facts bounded by a span of time mixes dimensions (C18) — weigh the source with weigh(duration(field)), or bound by a u64 field or literal">
+	: unknown
+
 /** The projected kind of one field of a face's source, read off the schema type. */
 type KindAt<S extends FaceSource, K extends string> =
 	ProjectedShape<S, K> extends readonly [infer Kind, ...unknown[]] ? Kind : undefined
@@ -450,5 +464,14 @@ function duration<const F extends string>(field: F & PathBan<F>): DurationRef<F>
 	return Object.freeze({ kind: "durationField", field: assertRowLocal(field, "Duration measure") }) as DurationRef<F>
 }
 
-export type { BoundsOnTarget, CapacityWeight, CapacityWindow, DurationRef, FieldRef, UnitWindowBan, WeightOnSource }
+export type {
+	BoundsOnTarget,
+	CapacityWeight,
+	CapacityWindow,
+	DurationRef,
+	FieldRef,
+	UnitDimensionBan,
+	UnitWindowBan,
+	WeightOnSource
+}
 export { duration, isCapacityWeight, isCapacityWindow, ref, unitWeight, weigh, within }

package/src/index.ts

@@ -119,7 +119,7 @@ export type {
 	Staleness,
 	StatementKindTag
 } from "#native.ts"
-export type { Desc, SortKey } from "#order.ts"
+export type { Desc, EngineOrderable, SortKey } from "#order.ts"
 export { by, desc } from "#order.ts"
 
 export type {

package/src/order.ts

@@ -10,6 +10,16 @@
  * `by(...)` into one row-typed comparator. Cross-type cells cannot arise
  * within one column (one column, one domain), and the cell order is TOTAL
  * anyway (the type-rank wall), so the comparator never throws.
+ *
+ * ZERO keys is the identity key (ruled 2026-07-25): `by()` / `desc()` are
+ * the same two spellings over BARE scalar arrays (`bigint[]` of ids, map
+ * keys) — with no column to name, the value itself is the key, there is
+ * nothing to fold, and the comparator IS the result. One ordering
+ * vocabulary, no sibling names. The identity arms are typed to EXACTLY the
+ * engine-orderable roster ({@link EngineOrderable}) because a bare scalar
+ * carries no decoded-row provenance — the type wall must carry the
+ * orderability law itself, where the row arm's cells arrive under their
+ * columns' law-typed proof.
  */
 
 import type { FactValue } from "#native.ts"
@@ -23,6 +33,23 @@ interface Desc<K extends string> {
 /** One sort key: a bare column name (ascending — the punning spelling) or `desc(name)`. */
 type SortKey<K extends string> = K | Desc<K>
 
+/**
+ * The engine-orderable scalar roster in the SDK's representation — `bigint`
+ * (U64/I64) and `boolean` (false < true — the strict 0/1 encoding IS the
+ * order), EXACTLY as `docs/architecture/10-data-model.md` § "Orderability,
+ * complete" admits it (ruled 2026-07-23, R3/R4), and nothing more:
+ * `string` is deliberately absent (intern ids are meaningless to order — a
+ * typed refusal, not a gap) and `number` is not an engine scalar at all.
+ * The identity comparators `by()`/`desc()` constrain on this alias, so
+ * sorting a `string[]` or `number[]` through them is a COMPILE error naming
+ * this roster. ONE OWNER for scalar ordering semantics: both identity arms
+ * route through the same cell order the row arm uses, whose bigint and
+ * boolean arms mirror the engine's U64/I64/Bool order exactly — a host
+ * sort over these values can never disagree with an engine order judgment
+ * (`Lt`-family, `Min`/`Max`) over the same column.
+ */
+type EngineOrderable = bigint | boolean
+
 /**
  * The type-rank wall: boolean 0, bigint 1, string 2, bytes 3, interval 4.
  * One column carries one domain, so a mixed pair never arises from decoded
@@ -116,8 +143,38 @@ function cellCmp(left: FactValue, right: FactValue): number {
 	return cellRank(left) - cellRank(right)
 }
 
-/** Marks one sort key DESCENDING — the single descending spelling (a bare name is already ascending). */
-function desc<const K extends string>(key: K): Desc<K> {
+/**
+ * The ascending identity comparator `by()` returns — one value, minted
+ * once (`by() === by()`), {@link cellCmp} narrowed to the engine-orderable
+ * roster (the one owner of the cell order).
+ */
+function identityAscending<T extends EngineOrderable>(left: T, right: T): number {
+	return cellCmp(left, right)
+}
+
+/** The descending identity comparator `desc()` returns — the same owner, sides flipped. */
+function identityDescending<T extends EngineOrderable>(left: T, right: T): number {
+	return cellCmp(right, left)
+}
+
+/**
+ * The descending spelling — ONE name, both arities of one ordering
+ * vocabulary. `desc(name)` marks one sort key DESCENDING: plain data for
+ * {@link by} to fold (a bare name is already ascending). `desc()` — zero
+ * keys, the identity key (ruled 2026-07-25) — is the descending comparator
+ * over engine-orderable scalars themselves: a bare `bigint[]` or
+ * `boolean[]` has no column to name, so the value IS the key, there is
+ * nothing to fold, and the comparator is the result directly. The identity
+ * arm covers EXACTLY the {@link EngineOrderable} roster — `string` and
+ * `number` refuse at compile time, citing the orderability law
+ * (`10-data-model.md` § "Orderability, complete").
+ */
+function desc(): <T extends EngineOrderable>(left: T, right: T) => number
+function desc<const K extends string>(key: K): Desc<K>
+function desc<const K extends string>(key?: K): Desc<K> | (<T extends EngineOrderable>(left: T, right: T) => number) {
+	if (key === undefined) {
+		return identityDescending
+	}
 	const marker: Desc<K> = { key, desc: true }
 	return Object.freeze(marker)
 }
@@ -130,12 +187,33 @@ function desc<const K extends string>(key: K): Desc<K> {
  * carries that proof here (parse-don't-validate). The generic RETURN is the
  * load-bearing trick: `rows.sort(by("rank"))` instantiates `Row` from the
  * array's own element type and checks the key set right there.
+ *
+ * ZERO keys is the identity key (ruled 2026-07-25): `by()` is the
+ * ascending comparator over engine-orderable scalars themselves —
+ * `ids.sort(by())` — for the bare arrays (`bigint[]`, map keys) the
+ * row-typed arm cannot reach because they have no column to name. One
+ * vocabulary, both arities. The identity arm is typed to EXACTLY the
+ * {@link EngineOrderable} roster: with no law-typed column standing proof
+ * over the values, the type wall carries the orderability law itself —
+ * `string` ordering is deliberately refused and `number` is not an engine
+ * scalar (`10-data-model.md` § "Orderability, complete"), so both refuse
+ * at compile time and a host sort can never disagree with an engine order
+ * judgment.
  */
+function by(): <T extends EngineOrderable>(left: T, right: T) => number
 function by<const K extends string>(
 	first: SortKey<K>,
 	...rest: ReadonlyArray<SortKey<K>>
-): <Row extends Readonly<Record<K, FactValue>>>(left: Row, right: Row) => number {
-	const entries = [first, ...rest].map(function normalizeKey(sortKey): { readonly key: K; readonly factor: 1 | -1 } {
+): <Row extends Readonly<Record<K, FactValue>>>(left: Row, right: Row) => number
+function by<const K extends string>(
+	...keys: ReadonlyArray<SortKey<K>>
+):
+	| (<T extends EngineOrderable>(left: T, right: T) => number)
+	| (<Row extends Readonly<Record<K, FactValue>>>(left: Row, right: Row) => number) {
+	if (keys.length === 0) {
+		return identityAscending
+	}
+	const entries = keys.map(function normalizeKey(sortKey): { readonly key: K; readonly factor: 1 | -1 } {
 		if (typeof sortKey === "string") {
 			return { key: sortKey, factor: 1 }
 		}
@@ -152,5 +230,5 @@ function by<const K extends string>(
 	}
 }
 
-export type { Desc, SortKey }
+export type { Desc, EngineOrderable, SortKey }
 export { by, desc }

package/src/query/atom.ts

@@ -46,7 +46,7 @@ import type {
 	SetParam,
 	ShapeOf
 } from "#query/scope.ts"
-import { inferred, isTerm } from "#query/scope.ts"
+import { inferred, isTerm, term } from "#query/scope.ts"
 import type { FieldsShape } from "#relation.ts"
 
 /**
@@ -335,8 +335,8 @@ type EqRight = AnyVar | Param<string> | SetParam<string> | bigint | string | boo
 /** 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). */
-type OrderSide = AnyVar | Param<string> | Duration | bigint
+/** 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
 
 /** The point side of `pointIn`. */
 type PointSide = AnyVar | Param<string> | bigint
@@ -350,14 +350,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`
 		)
 	}
 }
@@ -388,7 +402,7 @@ 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, never intervals/bytes/strings/bools. */
+/** 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)
 }
@@ -531,34 +545,159 @@ function isRecTarget(value: MatchOwner | RecTarget): value is RecTarget {
 }
 
 /**
- * Whether a variable's OWN field is orderable (u64/i64). A CLOSED reference
+ * 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
+ * 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`
  * § orderability), so every order-comparison and fold position refuses
- * closed-bound terms — this judgment is the one gate they all read, and the
- * construction-time validations in `#query/lower.ts` are its runtime twin.
+ * closed-bound terms — the construction-time validations in
+ * `#query/lower.ts` are that ban's runtime twin.
  */
-type OrderVarOk<V extends AnyVar> = V["field"] extends { readonly closed: ClosedRoster }
+type NumericVarOk<V extends AnyVar> = V["field"] extends { readonly closed: ClosedRoster }
 	? false
 	: V["field"]["kind"] extends "u64" | "i64"
 		? 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
 
-/** 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. */
-type PointSideOk<T> = T extends AnyVar ? OrderVarOk<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
@@ -632,10 +771,13 @@ type NotIdbOk<Classes extends SchemaClasses, Head, B> =
 
 /**
  * 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
@@ -643,17 +785,11 @@ 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]>
@@ -677,8 +813,18 @@ type EqParams<L, R> = L extends AnyVar
 			: never
 	: never
 
-/** An order side's params contribution (order params are always `bigint`). */
-type OrderSideParams<T> = T extends Param<infer P extends string> ? { readonly [Q in P]: bigint } : 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
@@ -697,9 +843,9 @@ type CondParams<C> = [AnyTreeChild] extends [C]
 		? Op extends "eq" | "ne"
 			? EqParams<L, R>
 			: Op extends "lt" | "le" | "gt" | "ge"
-				? OrderSideParams<L> | OrderSideParams<R>
+				? OrderSideParams<L, R> | OrderSideParams<R, L>
 				: Op extends "pointIn"
-					? IntervalSideParams<L> | OrderSideParams<R>
+					? IntervalSideParams<L> | PointParams<R>
 					: Op extends "allen"
 						? IntervalSideParams<L> | IntervalSideParams<R> | MaskParams<M>
 						: never
@@ -749,6 +895,7 @@ export type {
 	MatchShape,
 	NotAtom,
 	NotIdbAtom,
+	NumericVarOk,
 	OrderSide,
 	OrderVarOk,
 	ParamUse,

package/src/query/find.ts

@@ -21,7 +21,7 @@
 
 import type { Infer } from "#fields.ts"
 import type { SchemaClasses } from "#law.ts"
-import type { IntervalVarOk, OrderVarOk } from "#query/atom.ts"
+import type { IntervalVarOk, NumericVarOk, OrderVarOk } from "#query/atom.ts"
 import type { AnyVar, Duration, MintSlotOf } from "#query/scope.ts"
 
 /** One aggregate operator name of the find vocabulary. */
@@ -71,20 +71,21 @@ function countDistinct<const V extends AnyVar>(over: V): Agg<"countDistinct", V>
 }
 
 /**
- * Exact checked sum over an orderable (u64/i64) variable — wide
- * accumulator, one finalize range check; overflow is the engine's typed
- * runtime error — or over the measure (`r.sum(r.duration(w))`).
+ * Exact checked sum over a NUMERIC (u64/i64) variable — wide accumulator,
+ * one finalize range check; overflow is the engine's typed runtime error —
+ * or over the measure (`r.sum(r.duration(w))`). Bool stays refused: a
+ * quantifier is not an addition (R3).
  */
 function sum<const O extends AnyVar | Duration>(over: O): Agg<"sum", O> {
 	return aggregate("sum", over, undefined)
 }
 
-/** Minimum over an orderable variable or the measure (orderable types only). */
+/** Minimum over an orderable variable (u64/i64/bool — over bool, `Min` is the ALL quantifier; R3) or the measure. */
 function min<const O extends AnyVar | Duration>(over: O): Agg<"min", O> {
 	return aggregate("min", over, undefined)
 }
 
-/** Maximum over an orderable variable or the measure (orderable types only). */
+/** Maximum over an orderable variable (u64/i64/bool — over bool, `Max` is the ANY quantifier; R3) or the measure. */
 function max<const O extends AnyVar | Duration>(over: O): Agg<"max", O> {
 	return aggregate("max", over, undefined)
 }
@@ -116,7 +117,22 @@ function pack<const V extends AnyVar>(over: V): Agg<"pack", V> {
 	return aggregate("pack", over, undefined)
 }
 
-/** A fold input's judgment: an orderable variable, or the measure of an interval variable. */
+/**
+ * A `sum` input's judgment: a NUMERIC variable — Sum over bool stays
+ * refused, a quantifier is not an addition (R3) — or the measure of an
+ * interval variable.
+ */
+type SumOverOk<O> = O extends AnyVar
+	? NumericVarOk<O>
+	: O extends Duration<infer V extends AnyVar>
+		? IntervalVarOk<V>
+		: false
+
+/**
+ * A `min`/`max` input's judgment: an ORDERABLE variable — bool folds:
+ * `Max` is Any and `Min` is All, the two quantifiers as the 0/1 encoding's
+ * extremes (R3) — or the measure of an interval variable.
+ */
 type FoldOverOk<O> = O extends AnyVar
 	? OrderVarOk<O>
 	: O extends Duration<infer V extends AnyVar>
@@ -136,15 +152,17 @@ type FindEntryOk<E> = E extends AnyVar
 			? true
 			: E extends Agg<"countDistinct", AnyVar>
 				? true
-				: E extends Agg<"sum" | "min" | "max", infer O>
-					? FoldOverOk<O>
-					: E extends Agg<"argMax" | "argMin", AnyVar, infer K extends AnyVar>
-						? OrderVarOk<K> extends true
-							? true
-							: false
-						: E extends Agg<"pack", infer V extends AnyVar>
-							? IntervalVarOk<V>
-							: false
+				: E extends Agg<"sum", infer O>
+					? SumOverOk<O>
+					: E extends Agg<"min" | "max", infer O>
+						? FoldOverOk<O>
+						: E extends Agg<"argMax" | "argMin", AnyVar, infer K extends AnyVar>
+							? OrderVarOk<K> extends true
+								? true
+								: false
+							: E extends Agg<"pack", infer V extends AnyVar>
+								? IntervalVarOk<V>
+								: false
 
 /** The validated find record (intersect with the inferred entries — errors land on the offending key). */
 type CheckFind<F extends FindShape> = {

package/src/query/lower.ts

@@ -1327,7 +1327,12 @@ 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.
+ * 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[] {
 	const order: string[] = []
@@ -1338,7 +1343,6 @@ function paramRegistryOf(recs: readonly RecData[], rules: readonly RuleData[]):
 			anchor: ParamEntry["anchor"]
 			op: ParamEntry["op"]
 			members: readonly string[] | undefined
-			orderOp: "lt" | "le" | "gt" | "ge" | "pointIn" | undefined
 		}
 	>()
 	function fold(uses: readonly ParamUse[]): void {
@@ -1350,8 +1354,7 @@ function paramRegistryOf(recs: readonly RecData[], rules: readonly RuleData[]):
 					shape: use.shape,
 					anchor: use.anchor,
 					op: use.op,
-					members: use.members,
-					orderOp: isOrderOp(use.op) ? use.op : undefined
+					members: use.members
 				})
 				continue
 			}
@@ -1378,9 +1381,6 @@ function paramRegistryOf(recs: readonly RecData[], rules: readonly RuleData[]):
 				existing.anchor = use.anchor
 				existing.op = use.op
 			}
-			if (existing.orderOp === undefined && isOrderOp(use.op)) {
-				existing.orderOp = use.op
-			}
 		}
 	}
 	for (const rec of recs) {
@@ -1397,10 +1397,6 @@ function paramRegistryOf(recs: readonly RecData[], rules: readonly RuleData[]):
 			if (entry === undefined) {
 				throw errors.new(`query param ${name} lost its registry entry`)
 			}
-			const anchorRoster = anchorRosterOf(entry.anchor)
-			if (entry.orderOp !== undefined && anchorRoster !== undefined) {
-				throw closedOrderError(`query param ${name}`, `its ${entry.orderOp} use's anchor`, anchorRoster.name)
-			}
 			/**
 			 * A membership array's handle names are program constants, so the
 			 * entry stores the resolved IMAGE: each name rides the one