@bjornpagen/bumbledb 0.5.0 → 0.7.0

package/src/schema.ts

@@ -13,11 +13,11 @@ import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import { isClosedMember, sealedFieldOf } from "#closed.ts"
 import type { FaceData } from "#face.ts"
-import { assertDeclarationOrderKey, rosterOf } from "#fields.ts"
+import { assertDeclarationOrderKey, assertDeclarationRecord, rosterOf } from "#fields.ts"
 import { type ClassesOf, classesComplete, computeClasses, type LawfulStatements, type SchemaClasses } from "#law.ts"
 import type { AnyRelation } from "#relation.ts"
 import type { LiteralSetSpec, LiteralSpec } from "#spec.ts"
-import { renderStatement, type Statement } from "#statements.ts"
+import { isStatement, renderStatement, type Statement } from "#statements.ts"
 
 /**
  * Validates the relation record and collects the implied keys: the
@@ -27,6 +27,7 @@ import { renderStatement, type Statement } from "#statements.ts"
  * single spelling authority.
  */
 function collectImplied(name: string, relations: SchemaRelations): Set<string> {
+	assertDeclarationRecord(`schema ${name} relations`, relations)
 	const implied = new Set<string>()
 	for (const [recordKey, member] of Object.entries(relations)) {
 		assertDeclarationOrderKey(`schema ${name} relation`, recordKey)
@@ -297,6 +298,17 @@ function schema<const Rels extends SchemaRelations, const Stmts extends readonly
 	const implied = collectImplied(name, relations)
 	const seen = new Set<string>()
 	for (const statement of statements) {
+		/**
+		 * The untyped caller's half of the admission brand: the type tier
+		 * already refuses an unbranded structural literal, and this probe
+		 * refuses the same forgery at runtime — a statement that skipped the
+		 * construction-time arity and roster walls never enters the theory.
+		 */
+		if (!isStatement(statement)) {
+			throw errors.new(
+				`schema ${name}: a statement is minted only by key/contained/mirrors/window — a structural literal skips the construction-time arity and roster walls`
+			)
+		}
 		const rendered = renderStatement(statement)
 		verifyMembership(name, relations, statement, rendered)
 		if (implied.has(rendered)) {

package/src/spec.ts

@@ -118,19 +118,30 @@ interface RowSpec {
 }
 
 /**
- * One relation. `extension: rows` declares it closed (the option is the
- * kind); a closed relation's `fields` are its declared intrinsic columns
- * only — the synthetic (`id`, u64) handle field is materialized by the
- * engine's schema validation. `newtype` is the handle newtype of a closed
- * relation (the SDK emits the id's law-computed generator class,
- * `` `${name}.id` `` — the same label every referencing field carries by
- * law), undefined on an ordinary one.
+ * A relation's closedness as ONE sum (ruled 2026-07-23, R7): the handle
+ * newtype and the ground axioms travel together — the two illegal states
+ * (a roster without its newtype, a newtype without its roster) are
+ * unspellable on the wire exactly as they are unrepresentable in the
+ * fused Rust `RelationSpec`. `newtype` is the id's law-computed generator
+ * class (`` `${name}.id` `` — the same label every referencing field
+ * carries by law), which is how the engine resolves a handle literal back
+ * to its roster.
+ */
+interface ClosedSpec {
+	readonly newtype: string
+	readonly rows: readonly RowSpec[]
+}
+
+/**
+ * One relation. A present `closed` declares it closed (the option is the
+ * kind, one sum — R7); a closed relation's `fields` are its declared
+ * intrinsic columns only — the synthetic (`id`, u64) handle field is
+ * materialized by the engine's schema validation.
  */
 interface RelationSpec {
 	readonly name: string
-	readonly newtype: string | undefined
 	readonly fields: readonly FieldSpec[]
-	readonly extension: readonly RowSpec[] | undefined
+	readonly closed: ClosedSpec | undefined
 }
 
 /**
@@ -313,6 +324,7 @@ function renderWindow(window: WindowSpec): string {
 }
 
 export type {
+	ClosedSpec,
 	FieldSpec,
 	LiteralSetSpec,
 	LiteralSpec,

package/src/statements.ts

@@ -74,9 +74,33 @@ interface WindowData<Tgt extends FaceData = FaceData, Src extends FaceData = Fac
 /** One statement's runtime description, tagged by form. */
 type StatementData = KeyData<AnyRelation, readonly string[]> | ContainmentData | WindowData
 
-/** An opaque statement value — what `schema()` assembles into a theory. */
+/**
+ * The admission brand — a module-private symbol, deliberately unexported
+ * (the `count.ts` pattern): `Statement` is a public structural type, so
+ * without this brand a forged plain object of the right shape would walk
+ * past the construction-time arity and roster walls into `schema()` — and
+ * the roster wall is the one the engine cannot backstop (the wire carries
+ * plain u64s, no rosters). The symbol makes the four constructors the ONLY
+ * mints, so a statement that skipped the walls is unspellable.
+ */
+const admitted: unique symbol = Symbol("bumbledb.statement.admitted")
+
+/** An opaque statement value — what `schema()` assembles into a theory. Only the four constructors produce one. */
 interface Statement {
 	readonly data: StatementData
+	readonly [admitted]: true
+}
+
+/**
+ * Narrows any value to an admitted statement — the probe is the
+ * module-private {@link admitted} brand only the four constructors set, so
+ * no host-built value (fact cells are structurally OPEN — an interval with
+ * an excess `kind` property is a legal cell) can ever be misread as one.
+ * The keyed-get selector dispatch and `schema()`'s admission both judge
+ * through here.
+ */
+function isStatement(value: unknown): value is Statement {
+	return typeof value === "object" && value !== null && admitted in value
 }
 
 /**
@@ -188,7 +212,7 @@ function key<
 		owner: relation,
 		projection: Object.freeze(fields)
 	})
-	return Object.freeze({ data })
+	return Object.freeze({ data, [admitted]: true as const })
 }
 
 /**
@@ -210,7 +234,7 @@ function contained<A extends AnyFace, B extends AnyFace>(
 		target: target.data,
 		bidirectional: false
 	})
-	const statement = Object.freeze({ data })
+	const statement = Object.freeze({ data, [admitted]: true as const })
 	assertArityAgreement(data.source, data.target, statement)
 	assertRosterAgreement(data.source, data.target, statement)
 	return statement
@@ -235,7 +259,7 @@ function mirrors<A extends AnyFace, B extends AnyFace>(
 		target: target.data,
 		bidirectional: true
 	})
-	const statement = Object.freeze({ data })
+	const statement = Object.freeze({ data, [admitted]: true as const })
 	assertArityAgreement(data.source, data.target, statement)
 	assertRosterAgreement(data.source, data.target, statement)
 	return statement
@@ -262,7 +286,7 @@ function window<B extends AnyFace, A extends AnyFace>(
 		window: count.window,
 		source: source.data
 	})
-	const statement = Object.freeze({ data })
+	const statement = Object.freeze({ data, [admitted]: true as const })
 	assertArityAgreement(data.source, data.target, statement)
 	assertRosterAgreement(data.source, data.target, statement)
 	return statement
@@ -302,4 +326,4 @@ export type {
 	WindowData,
 	WindowStatement
 }
-export { contained, key, mirrors, renderStatement, window }
+export { contained, isStatement, key, mirrors, renderStatement, window }

package/dist/query/select.d.ts

@@ -1,128 +0,0 @@
-/**
- * Select entries and aggregates, STRUCTURAL edition — the head 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; a tie yields every attaining row), and `pack` (the coalescing fold —
- * RELATION-SHAPED: one answer row per (group, maximal segment), the result
- * position interval-typed). Aggregates name their variables — `r.sum("m")`
- * — and are typed by the rule environment at `.select`. Grouping is
- * implicit: the non-aggregate select entries are the group key; over empty
- * input an all-aggregate select yields the EMPTY SET, never a zero row.
- * The creation quarantine is representational: a head position is a var
- * name, the measure, or an aggregate — no minting or arithmetic term
- * exists to spell (permanent law).
- */
-import type { Infer } from "#fields.ts";
-import type { IntervalVarOk, OrderVarOk } from "#query/atom.ts";
-import type { Duration, EnvShape, ShapeOf } from "#query/scope.ts";
-/** One aggregate operator name of the select vocabulary. */
-type AggOpName = "count" | "countDistinct" | "sum" | "min" | "max" | "argMax" | "argMin" | "pack";
-/**
- * One aggregate select VALUE: the op, the variable name (or measure) it
- * folds, and — for the Arg forms — the orderable key's variable name. The
- * runtime representation carries the types; the rule environment types the
- * result at `.select`.
- */
-interface Agg<Op extends AggOpName, Over extends string | Duration<string> | undefined, Key extends string | undefined = undefined> {
-    readonly agg: Op;
-    readonly over: Over;
-    readonly key: Key;
-}
-/** Any aggregate select value. */
-type AnyAgg = Agg<AggOpName, string | Duration<string> | undefined, string | undefined>;
-/** One select entry: a projected var name, the measure, or an aggregate. */
-type SelectEntry = string | Duration<string> | AnyAgg;
-/** Nullary count: |the group's set of distinct full bindings|, `bigint`; the answer column is named `count`. */
-declare function count(): Agg<"count", undefined>;
-/** |the distinct values of the named variable across the group|, `bigint`; legal over every type. */
-declare function countDistinct<const N extends string>(over: N): Agg<"countDistinct", N>;
-/**
- * Exact checked sum over an orderable (u64/i64) variable — wide
- * accumulator, one finalize range check; overflow is the engine's typed
- * runtime error, never a wrap — or over the measure
- * (`r.sum(r.duration("w"))`).
- */
-declare function sum<const N extends string | Duration<string>>(over: N): Agg<"sum", N>;
-/** Minimum over an orderable variable or the measure (orderable types only). */
-declare function min<const N extends string | Duration<string>>(over: N): Agg<"min", N>;
-/** Maximum over an orderable variable or the measure (orderable types only). */
-declare function max<const N extends string | Duration<string>>(over: N): Agg<"max", N>;
-/**
- * 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 typed
- * rules).
- */
-declare function argMax<const V extends string, const K extends string>(value: V, key: K): Agg<"argMax", V, K>;
-/** Arg-restriction toward the minimum of `key`; rules as {@link argMax}. */
-declare function argMin<const V extends string, const K extends string>(value: V, key: K): Agg<"argMin", V, K>;
-/**
- * The coalescing fold (Snodgrass coalesce, `ir::AggOp::Pack`): per group,
- * 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 select, never beside a
- * fold or an Arg entry (the engine's typed rules).
- */
-declare function pack<const N extends string>(over: N): Agg<"pack", N>;
-/** A fold input's judgment: an orderable variable, or the measure of an interval variable. */
-type FoldOverOk<Env extends EnvShape, O> = O extends string ? OrderVarOk<Env, O> : O extends Duration<infer N extends string> ? IntervalVarOk<Env, N> : false;
-/**
- * One select entry's judgment against the rule environment: projected
- * names must be bound, the measure and `pack` demand interval-typed
- * variables, folds and Arg keys demand orderable ones.
- */
-type SelectEntryOk<Env extends EnvShape, E> = E extends string ? E extends keyof Env ? true : false : E extends Duration<infer N extends string> ? IntervalVarOk<Env, N> : E extends Agg<"count", undefined> ? true : E extends Agg<"countDistinct", infer O extends string> ? O extends keyof Env ? true : false : E extends Agg<"sum" | "min" | "max", infer O> ? FoldOverOk<Env, O> : E extends Agg<"argMax" | "argMin", infer O extends string, infer K extends string> ? [O extends keyof Env ? true : false, OrderVarOk<Env, K>] extends [true, true] ? true : false : E extends Agg<"pack", infer O extends string> ? IntervalVarOk<Env, O> : false;
-/** The validated select tuple (intersect with the inferred entries — errors land on the offending argument). */
-type CheckSelect<Env extends EnvShape, S> = {
-    readonly [I in keyof S]: SelectEntryOk<Env, S[I]> extends true ? S[I] : never;
-};
-/** The validated names-only select tuple of a RECURSIVE rule (aggregates and the measure are unwritable there). */
-type CheckNameSelect<Env extends EnvShape, S> = {
-    readonly [I in keyof S]: S[I] extends keyof Env ? S[I] : never;
-};
-/**
- * One select entry's answer-column fragment: the column is named by the
- * variable it projects or folds (`count` names its column `count`), and
- * its type reflects the entry — `count`/`countDistinct` are `bigint`
- * whatever they counted, folds carry their input's type, the measure is
- * `bigint`, the Arg forms carry the payload's type, `pack` its interval
- * type.
- */
-type SelectEntryRow<Env extends EnvShape, E> = E extends string ? {
-    readonly [K in E]: Infer<Env[E & keyof Env]["field"]>;
-} : E extends Duration<infer N extends string> ? {
-    readonly [K in N]: bigint;
-} : E extends Agg<"count", undefined> ? {
-    readonly count: bigint;
-} : E extends Agg<"countDistinct", infer O extends string> ? {
-    readonly [K in O]: bigint;
-} : E extends Agg<"sum" | "min" | "max", infer O> ? O extends string ? {
-    readonly [K in O]: Infer<Env[O & keyof Env]["field"]>;
-} : O extends Duration<infer N extends string> ? {
-    readonly [K in N]: bigint;
-} : never : E extends Agg<"argMax" | "argMin", infer O extends string, string> ? {
-    readonly [K in O]: Infer<Env[O & keyof Env]["field"]>;
-} : E extends Agg<"pack", infer O extends string> ? {
-    readonly [K in O]: Infer<Env[O & keyof Env]["field"]>;
-} : never;
-/** The inferred answer-row object type of a select tuple. */
-type RowOfSelect<Env extends EnvShape, S extends readonly SelectEntry[]> = ShapeOf<SelectEntryRow<Env, S[number]>>;
-/**
- * One projected name's answer-column fragment — a NAKED parameter, so the
- * judgment distributes per name (the union of a multi-name select never
- * smears into one column's type), mirroring {@link SelectEntryRow}.
- */
-type NameSelectRow<Env extends EnvShape, N> = N extends string ? {
-    readonly [K in N]: Infer<Env[K & keyof Env]["field"]>;
-} : never;
-/** The inferred answer-row object type of a names-only (recursive-rule) select tuple. */
-type RowOfNameSelect<Env extends EnvShape, S extends readonly string[]> = ShapeOf<NameSelectRow<Env, S[number]>>;
-export type { Agg, AggOpName, AnyAgg, CheckNameSelect, CheckSelect, RowOfNameSelect, RowOfSelect, SelectEntry, SelectEntryOk, SelectEntryRow };
-export { argMax, argMin, count, countDistinct, max, min, pack, sum };
-//# sourceMappingURL=select.d.ts.map

package/dist/query/select.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/query/select.ts"],"names":[],"mappings":"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"}

package/dist/query/select.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"select.js","sourceRoot":"","sources":["../../src/query/select.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AA+BH,kCAAkC;AAClC,SAAS,SAAS,CAIhB,EAAM,EAAE,IAAU,EAAE,GAAQ;IAC7B,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAA;AAC7C,CAAC;AAED,gHAAgH;AAChH,SAAS,KAAK;IACb,OAAO,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;AAChD,CAAC;AAED,qGAAqG;AACrG,SAAS,aAAa,CAAyB,IAAO;IACrD,OAAO,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AACnD,CAAC;AAED;;;;;GAKG;AACH,SAAS,GAAG,CAA4C,IAAO;IAC9D,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AACzC,CAAC;AAED,gFAAgF;AAChF,SAAS,GAAG,CAA4C,IAAO;IAC9D,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AACzC,CAAC;AAED,gFAAgF;AAChF,SAAS,GAAG,CAA4C,IAAO;IAC9D,OAAO,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AACzC,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,MAAM,CAAiD,KAAQ,EAAE,GAAM;IAC/E,OAAO,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,CAAA;AACvC,CAAC;AAED,4EAA4E;AAC5E,SAAS,MAAM,CAAiD,KAAQ,EAAE,GAAM;IAC/E,OAAO,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,CAAA;AACvC,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,IAAI,CAAyB,IAAO;IAC5C,OAAO,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;AAC1C,CAAC;AAqGD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAA"}

package/src/query/select.ts

@@ -1,215 +0,0 @@
-/**
- * Select entries and aggregates, STRUCTURAL edition — the head 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; a tie yields every attaining row), and `pack` (the coalescing fold —
- * RELATION-SHAPED: one answer row per (group, maximal segment), the result
- * position interval-typed). Aggregates name their variables — `r.sum("m")`
- * — and are typed by the rule environment at `.select`. Grouping is
- * implicit: the non-aggregate select entries are the group key; over empty
- * input an all-aggregate select yields the EMPTY SET, never a zero row.
- * The creation quarantine is representational: a head position is a var
- * name, the measure, or an aggregate — no minting or arithmetic term
- * exists to spell (permanent law).
- */
-
-import type { Infer } from "#fields.ts"
-import type { IntervalVarOk, OrderVarOk } from "#query/atom.ts"
-import type { Duration, EnvShape, ShapeOf } from "#query/scope.ts"
-
-/** One aggregate operator name of the select vocabulary. */
-type AggOpName = "count" | "countDistinct" | "sum" | "min" | "max" | "argMax" | "argMin" | "pack"
-
-/**
- * One aggregate select VALUE: the op, the variable name (or measure) it
- * folds, and — for the Arg forms — the orderable key's variable name. The
- * runtime representation carries the types; the rule environment types the
- * result at `.select`.
- */
-interface Agg<
-	Op extends AggOpName,
-	Over extends string | Duration<string> | undefined,
-	Key extends string | undefined = undefined
-> {
-	readonly agg: Op
-	readonly over: Over
-	readonly key: Key
-}
-
-/** Any aggregate select value. */
-type AnyAgg = Agg<AggOpName, string | Duration<string> | undefined, string | undefined>
-
-/** One select entry: a projected var name, the measure, or an aggregate. */
-type SelectEntry = string | Duration<string> | AnyAgg
-
-/** Builds one aggregate value. */
-function aggregate<
-	Op extends AggOpName,
-	Over extends string | Duration<string> | undefined,
-	Key extends string | undefined
->(op: Op, over: Over, key: Key): Agg<Op, Over, Key> {
-	return Object.freeze({ agg: op, over, key })
-}
-
-/** Nullary count: |the group's set of distinct full bindings|, `bigint`; the answer column is named `count`. */
-function count(): Agg<"count", undefined> {
-	return aggregate("count", undefined, undefined)
-}
-
-/** |the distinct values of the named variable across the group|, `bigint`; legal over every type. */
-function countDistinct<const N extends string>(over: N): Agg<"countDistinct", N> {
-	return aggregate("countDistinct", over, undefined)
-}
-
-/**
- * Exact checked sum over an orderable (u64/i64) variable — wide
- * accumulator, one finalize range check; overflow is the engine's typed
- * runtime error, never a wrap — or over the measure
- * (`r.sum(r.duration("w"))`).
- */
-function sum<const N extends string | Duration<string>>(over: N): Agg<"sum", N> {
-	return aggregate("sum", over, undefined)
-}
-
-/** Minimum over an orderable variable or the measure (orderable types only). */
-function min<const N extends string | Duration<string>>(over: N): Agg<"min", N> {
-	return aggregate("min", over, undefined)
-}
-
-/** Maximum over an orderable variable or the measure (orderable types only). */
-function max<const N extends string | Duration<string>>(over: N): Agg<"max", N> {
-	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 typed
- * rules).
- */
-function argMax<const V extends string, const K extends string>(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 string, const K extends string>(value: V, key: K): Agg<"argMin", V, K> {
-	return aggregate("argMin", value, key)
-}
-
-/**
- * The coalescing fold (Snodgrass coalesce, `ir::AggOp::Pack`): per group,
- * 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 select, never beside a
- * fold or an Arg entry (the engine's typed rules).
- */
-function pack<const N extends string>(over: N): Agg<"pack", N> {
-	return aggregate("pack", over, undefined)
-}
-
-/** A fold input's judgment: an orderable variable, or the measure of an interval variable. */
-type FoldOverOk<Env extends EnvShape, O> = O extends string
-	? OrderVarOk<Env, O>
-	: O extends Duration<infer N extends string>
-		? IntervalVarOk<Env, N>
-		: false
-
-/**
- * One select entry's judgment against the rule environment: projected
- * names must be bound, the measure and `pack` demand interval-typed
- * variables, folds and Arg keys demand orderable ones.
- */
-type SelectEntryOk<Env extends EnvShape, E> = E extends string
-	? E extends keyof Env
-		? true
-		: false
-	: E extends Duration<infer N extends string>
-		? IntervalVarOk<Env, N>
-		: E extends Agg<"count", undefined>
-			? true
-			: E extends Agg<"countDistinct", infer O extends string>
-				? O extends keyof Env
-					? true
-					: false
-				: E extends Agg<"sum" | "min" | "max", infer O>
-					? FoldOverOk<Env, O>
-					: E extends Agg<"argMax" | "argMin", infer O extends string, infer K extends string>
-						? [O extends keyof Env ? true : false, OrderVarOk<Env, K>] extends [true, true]
-							? true
-							: false
-						: E extends Agg<"pack", infer O extends string>
-							? IntervalVarOk<Env, O>
-							: false
-
-/** The validated select tuple (intersect with the inferred entries — errors land on the offending argument). */
-type CheckSelect<Env extends EnvShape, S> = {
-	readonly [I in keyof S]: SelectEntryOk<Env, S[I]> extends true ? S[I] : never
-}
-
-/** The validated names-only select tuple of a RECURSIVE rule (aggregates and the measure are unwritable there). */
-type CheckNameSelect<Env extends EnvShape, S> = {
-	readonly [I in keyof S]: S[I] extends keyof Env ? S[I] : never
-}
-
-/**
- * One select entry's answer-column fragment: the column is named by the
- * variable it projects or folds (`count` names its column `count`), and
- * its type reflects the entry — `count`/`countDistinct` are `bigint`
- * whatever they counted, folds carry their input's type, the measure is
- * `bigint`, the Arg forms carry the payload's type, `pack` its interval
- * type.
- */
-type SelectEntryRow<Env extends EnvShape, E> = E extends string
-	? { readonly [K in E]: Infer<Env[E & keyof Env]["field"]> }
-	: E extends Duration<infer N extends string>
-		? { readonly [K in N]: bigint }
-		: E extends Agg<"count", undefined>
-			? { readonly count: bigint }
-			: E extends Agg<"countDistinct", infer O extends string>
-				? { readonly [K in O]: bigint }
-				: E extends Agg<"sum" | "min" | "max", infer O>
-					? O extends string
-						? { readonly [K in O]: Infer<Env[O & keyof Env]["field"]> }
-						: O extends Duration<infer N extends string>
-							? { readonly [K in N]: bigint }
-							: never
-					: E extends Agg<"argMax" | "argMin", infer O extends string, string>
-						? { readonly [K in O]: Infer<Env[O & keyof Env]["field"]> }
-						: E extends Agg<"pack", infer O extends string>
-							? { readonly [K in O]: Infer<Env[O & keyof Env]["field"]> }
-							: never
-
-/** The inferred answer-row object type of a select tuple. */
-type RowOfSelect<Env extends EnvShape, S extends readonly SelectEntry[]> = ShapeOf<SelectEntryRow<Env, S[number]>>
-
-/**
- * One projected name's answer-column fragment — a NAKED parameter, so the
- * judgment distributes per name (the union of a multi-name select never
- * smears into one column's type), mirroring {@link SelectEntryRow}.
- */
-type NameSelectRow<Env extends EnvShape, N> = N extends string
-	? { readonly [K in N]: Infer<Env[K & keyof Env]["field"]> }
-	: never
-
-/** The inferred answer-row object type of a names-only (recursive-rule) select tuple. */
-type RowOfNameSelect<Env extends EnvShape, S extends readonly string[]> = ShapeOf<NameSelectRow<Env, S[number]>>
-
-export type {
-	Agg,
-	AggOpName,
-	AnyAgg,
-	CheckNameSelect,
-	CheckSelect,
-	RowOfNameSelect,
-	RowOfSelect,
-	SelectEntry,
-	SelectEntryOk,
-	SelectEntryRow
-}
-export { argMax, argMin, count, countDistinct, max, min, pack, sum }