@bjornpagen/bumbledb 0.10.0 → 0.12.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, term } 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 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
@@ -473,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)`
 		)
@@ -515,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
@@ -726,48 +727,15 @@ 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
@@ -795,8 +763,8 @@ type CondOkBool<Classes extends SchemaClasses, C> = [AnyTreeChild] extends [C]
 			? 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
@@ -829,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.
@@ -839,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"
@@ -847,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
@@ -885,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,

package/src/query/find.ts

@@ -3,11 +3,10 @@
  * vocabulary, mirroring the IR's aggregate roster exactly
  * (`bumbledb/crates/bumbledb/src/ir.rs` `AggOp`/`FindTerm`;
  * `docs/architecture/20-query-ir.md` § aggregation): `count` (nullary),
- * `countDistinct`, `sum`/`min`/`max` (over an orderable variable or the
- * measure), `argMax`/`argMin` (arg-restriction: carried value + orderable
- * key), and `pack` (the coalescing fold — RELATION-SHAPED, the result
- * position interval-typed). Aggregates fold VARIABLES by reference —
- * `r.sum(w)` — and are typed by the variable's own descriptor.
+ * `sum`/`min`/`max` (over an orderable variable or the measure), and
+ * `pack` (the coalescing fold — RELATION-SHAPED, the result position
+ * interval-typed). Aggregates fold VARIABLES by reference — `r.sum(w)` —
+ * and are typed by the variable's own descriptor.
  *
  * `select(strings)` is DEAD: the head is a `find` RECORD, whose KEYS name
  * the answer columns (`find({ total: r.count(), owner: h })`). The keys are
@@ -25,25 +24,19 @@ 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. */
-type AggOpName = "count" | "countDistinct" | "sum" | "min" | "max" | "argMax" | "argMin" | "pack"
+type AggOpName = "count" | "sum" | "min" | "max" | "pack"
 
 /**
- * One aggregate find VALUE: the op, the variable (or measure) it folds BY
- * REFERENCE, and — for the Arg forms — the orderable key variable. The
- * variable's own descriptor types the result.
+ * One aggregate find VALUE: the op and the variable (or measure) it folds
+ * BY REFERENCE. The variable's own descriptor types the result.
  */
-interface Agg<
-	Op extends AggOpName,
-	Over extends AnyVar | Duration | undefined,
-	Key extends AnyVar | undefined = undefined
-> {
+interface Agg<Op extends AggOpName, Over extends AnyVar | Duration | undefined> {
 	readonly agg: Op
 	readonly over: Over
-	readonly key: Key
 }
 
 /** Any aggregate find value. */
-type AnyAgg = Agg<AggOpName, AnyVar | Duration | undefined, AnyVar | undefined>
+type AnyAgg = Agg<AggOpName, AnyVar | Duration | undefined>
 
 /** One find entry: a projected variable, the measure, or an aggregate. */
 type FindEntry = AnyVar | Duration | AnyAgg
@@ -52,22 +45,16 @@ type FindEntry = AnyVar | Duration | AnyAgg
 type FindShape = Readonly<Record<string, FindEntry>>
 
 /** Builds one aggregate value. */
-function aggregate<Op extends AggOpName, Over extends AnyVar | Duration | undefined, Key extends AnyVar | undefined>(
+function aggregate<Op extends AggOpName, Over extends AnyVar | Duration | undefined>(
 	op: Op,
-	over: Over,
-	key: Key
-): Agg<Op, Over, Key> {
-	return Object.freeze({ agg: op, over, key })
+	over: Over
+): Agg<Op, Over> {
+	return Object.freeze({ agg: op, over })
 }
 
 /** Nullary count: |the group's set of distinct full bindings|, `bigint`. */
 function count(): Agg<"count", undefined> {
-	return aggregate("count", undefined, undefined)
-}
-
-/** |the distinct values of the variable across the group|, `bigint`; legal over every type. */
-function countDistinct<const V extends AnyVar>(over: V): Agg<"countDistinct", V> {
-	return aggregate("countDistinct", over, undefined)
+	return aggregate("count", undefined)
 }
 
 /**
@@ -77,33 +64,17 @@ function countDistinct<const V extends AnyVar>(over: V): Agg<"countDistinct", V>
  * quantifier is not an addition (R3).
  */
 function sum<const O extends AnyVar | Duration>(over: O): Agg<"sum", O> {
-	return aggregate("sum", over, undefined)
+	return aggregate("sum", over)
 }
 
 /** 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)
+	return aggregate("min", over)
 }
 
 /** 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)
-}
-
-/**
- * Arg-restriction toward the maximum of `key` (`ir::AggOp::ArgMax`): the
- * group's binding set is restricted to the bindings attaining the extreme
- * of the orderable key, and `value` is the carried payload — a tie yields
- * every attaining row. All Arg entries of one query share one key and one
- * direction; Arg and fold aggregates never mix (both the engine's rules).
- */
-function argMax<const V extends AnyVar, const K extends AnyVar>(value: V, key: K): Agg<"argMax", V, K> {
-	return aggregate("argMax", value, key)
-}
-
-/** Arg-restriction toward the minimum of `key`; rules as {@link argMax}. */
-function argMin<const V extends AnyVar, const K extends AnyVar>(value: V, key: K): Agg<"argMin", V, K> {
-	return aggregate("argMin", value, key)
+	return aggregate("max", over)
 }
 
 /**
@@ -111,10 +82,10 @@ function argMin<const V extends AnyVar, const K extends AnyVar>(value: V, key: K
  * the maximal disjoint half-open segments of the union of the group's
  * interval point sets — RELATION-SHAPED, one answer row per (group, maximal
  * segment), the result position carrying one interval of the input's element
- * type. At most one `pack` per find, never beside a fold or an Arg entry.
+ * type. At most one `pack` per find, never beside a fold entry.
  */
 function pack<const V extends AnyVar>(over: V): Agg<"pack", V> {
-	return aggregate("pack", over, undefined)
+	return aggregate("pack", over)
 }
 
 /**
@@ -142,7 +113,7 @@ type FoldOverOk<O> = O extends AnyVar
 /**
  * One find entry's judgment (off the entry's own descriptor — no env, no
  * class map needed): a projected variable is ok, the measure and `pack`
- * demand interval-typed variables, folds and Arg keys demand orderable ones.
+ * demand interval-typed variables, folds demand orderable ones.
  */
 type FindEntryOk<E> = E extends AnyVar
 	? true
@@ -150,19 +121,13 @@ type FindEntryOk<E> = E extends AnyVar
 		? IntervalVarOk<V>
 		: E extends Agg<"count", undefined>
 			? true
-			: E extends Agg<"countDistinct", AnyVar>
-				? true
-				: 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
+			: E extends Agg<"sum", infer O>
+				? SumOverOk<O>
+				: E extends Agg<"min" | "max", infer O>
+					? FoldOverOk<O>
+					: 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> = {
@@ -171,8 +136,7 @@ type CheckFind<F extends FindShape> = {
 
 /**
  * The validated find record of a RECURSIVE rule: every entry must be a plain
- * variable (aggregates and the measure are unwritable in a recursive head —
- * the strata quarantine).
+ * variable (aggregates and the measure are unwritable in a rec head).
  */
 type CheckRecFind<F extends FindShape> = {
 	readonly [K in keyof F]: F[K] extends AnyVar ? F[K] : never
@@ -180,9 +144,8 @@ type CheckRecFind<F extends FindShape> = {
 
 /**
  * One find entry's answer-column value type: a variable carries its field's
- * type, the measure/count/countDistinct are `bigint`, folds carry their
- * input's type (a measure fold is `bigint`), the Arg forms carry the
- * payload's type, `pack` its interval type.
+ * type, the measure/count are `bigint`, folds carry their input's type
+ * (a measure fold is `bigint`), `pack` its interval type.
  */
 type FindValue<E> = E extends AnyVar
 	? Infer<E["field"]>
@@ -190,17 +153,13 @@ type FindValue<E> = E extends AnyVar
 		? bigint
 		: E extends Agg<"count", undefined>
 			? bigint
-			: E extends Agg<"countDistinct", AnyVar>
-				? bigint
-				: E extends Agg<"sum" | "min" | "max", infer O>
-					? O extends AnyVar
-						? Infer<O["field"]>
-						: bigint
-					: E extends Agg<"argMax" | "argMin", infer V extends AnyVar, AnyVar>
-						? Infer<V["field"]>
-						: E extends Agg<"pack", infer V extends AnyVar>
-							? Infer<V["field"]>
-							: never
+			: E extends Agg<"sum" | "min" | "max", infer O>
+				? O extends AnyVar
+					? Infer<O["field"]>
+					: bigint
+				: E extends Agg<"pack", infer V extends AnyVar>
+					? Infer<V["field"]>
+					: never
 
 /** The inferred answer-row object type of a find record — the keys ARE the columns. */
 type RowOfFind<F extends FindShape> = { readonly [K in keyof F]: FindValue<F[K]> }
@@ -208,7 +167,7 @@ type RowOfFind<F extends FindShape> = { readonly [K in keyof F]: FindValue<F[K]>
 /**
  * The head signature of a recursive rule's find record as classed mint
  * slots (descriptor + law-computed class), keyed by column name — the
- * signature an `idb` join pairs against (`F` is variable-only there).
+ * signature an interior join pairs against (`F` is variable-only there).
  */
 type HeadRecordOf<Classes extends SchemaClasses, F extends FindShape> = {
 	readonly [K in keyof F]: F[K] extends AnyVar ? MintSlotOf<Classes, F[K]> : never
@@ -227,4 +186,4 @@ export type {
 	HeadRecordOf,
 	RowOfFind
 }
-export { argMax, argMin, count, countDistinct, max, min, pack, sum }
+export { count, max, min, pack, sum }