@bjornpagen/bumbledb 0.2.0 → 0.3.0

package/src/query/predicate.ts

@@ -28,6 +28,7 @@
  */
 
 import * as errors from "@superbuilders/errors"
+import type { SchemaClasses } from "#law.ts"
 import type { RecData } from "#query/atom.ts"
 import type {
 	AnyRuleValue,
@@ -61,42 +62,47 @@ interface Rec<
 	Rels extends SchemaRelations,
 	Name extends string,
 	P extends ParamsRecord,
-	Head extends HeadShape = undefined
+	Head extends HeadShape = undefined,
+	Classes extends SchemaClasses = SchemaClasses
 > extends RecRef<Name, P, Head> {
 	rule<RV extends AnyRuleValue>(
-		build: (r: RecRuleScope<Rels, Name>) => RV
-	): Rec<Rels, Name, Flatten<P & ParamsOf<RV>>, Head extends undefined ? HeadOf<RV> : Head>
+		build: (r: RecRuleScope<Rels, Name, Classes>) => RV
+	): Rec<Rels, Name, Flatten<P & ParamsOf<RV>>, Head extends undefined ? HeadOf<RV> : Head, Classes>
 	readonly [inferred]?: { readonly params: P; readonly head: Head }
 }
 
 /** One output-rule builder function. */
-type OutputBuild<Rels extends SchemaRelations> = (r: OutputRuleScope<Rels>) => AnyRuleValue
+type OutputBuild<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> = (
+	r: OutputRuleScope<Rels, Classes>
+) => AnyRuleValue
 
 /** A build function's rule value. */
 type BuiltRule<F> = F extends (r: never) => infer RV ? RV : never
 
 /** The union row of a tuple of output builds. */
-type OutputRow<Builds extends readonly OutputBuild<SchemaRelations>[]> = RowOf<BuiltRule<Builds[number]>>
+type OutputRow<Builds extends readonly OutputBuild<SchemaRelations, SchemaClasses>[]> = RowOf<BuiltRule<Builds[number]>>
 
 /** The intersected params record of a tuple of output builds. */
-type OutputParams<Builds extends readonly OutputBuild<SchemaRelations>[]> = ShapeOf<ParamsOf<BuiltRule<Builds[number]>>>
+type OutputParams<Builds extends readonly OutputBuild<SchemaRelations, SchemaClasses>[]> = ShapeOf<
+	ParamsOf<BuiltRule<Builds[number]>>
+>
 
 /**
  * The program scope: declare recs, attach their rules, then declare the
  * output — which seals the recs (a later `rec`/`rule` is a construction
  * error) and returns the program as an ordinary query value.
  */
-interface ProgramScope<Rels extends SchemaRelations> {
+interface ProgramScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> {
 	/** Declares one recursive predicate; declaration order = its dense `PredId`. */
-	rec<const Name extends string>(name: Name): Rec<Rels, Name, Record<never, never>>
+	rec<const Name extends string>(name: Name): Rec<Rels, Name, Record<never, never>, undefined, Classes>
 	/**
 	 * Declares the output predicate (one rule per build; multiple rules =
 	 * set union) and seals the program. Must be what the `program()`
 	 * callback returns.
 	 */
-	output<const Builds extends readonly OutputBuild<Rels>[]>(
+	output<const Builds extends readonly OutputBuild<Rels, Classes>[]>(
 		...builds: Builds
-	): Query<Rels, OutputRow<Builds>, OutputParams<Builds>>
+	): Query<Rels, OutputRow<Builds>, OutputParams<Builds>, Classes>
 }
 
 /** The runtime rec-handle shape beneath the typed `Rec` face. */
@@ -117,7 +123,7 @@ function makeRawRec<Name extends string>(state: ProgramState, name: Name, data:
 					`rec ${name}: the program's output is already declared — recursive rules attach before p.output`
 				)
 			}
-			const built = build(makeRawScope({ kind: "rec", self: data }))
+			const built = build(makeRawScope({ kind: "rec", self: data, classes: state.classes }))
 			const head = data.rules[0]
 			if (head !== undefined) {
 				const declared = head.select.map(function columnName(column) {
@@ -145,21 +151,24 @@ function makeRawRec<Name extends string>(state: ProgramState, name: Name, data:
  * the checkable fact — the handle owns exactly the rec data it names — is
  * verified before the raw handle is admitted at its typed face.
  */
-function isRecHandle<Rels extends SchemaRelations, Name extends string, P extends ParamsRecord>(
-	data: RecData,
-	rec: RawRec<Name>
-): rec is RawRec<Name> & Rec<Rels, Name, P> {
+function isRecHandle<
+	Rels extends SchemaRelations,
+	Name extends string,
+	P extends ParamsRecord,
+	Classes extends SchemaClasses
+>(data: RecData, rec: RawRec<Name>): rec is RawRec<Name> & Rec<Rels, Name, P, undefined, Classes> {
 	return rec.data === data
 }
 
 /** Builds one typed rec handle over shared rec data. */
-function makeRec<Rels extends SchemaRelations, Name extends string, P extends ParamsRecord>(
-	state: ProgramState,
-	name: Name,
-	data: RecData
-): Rec<Rels, Name, P> {
+function makeRec<
+	Rels extends SchemaRelations,
+	Name extends string,
+	P extends ParamsRecord,
+	Classes extends SchemaClasses
+>(state: ProgramState, name: Name, data: RecData): Rec<Rels, Name, P, undefined, Classes> {
 	const raw = makeRawRec<Name>(state, name, data)
-	if (!isRecHandle<Rels, Name, P>(data, raw)) {
+	if (!isRecHandle<Rels, Name, P, Classes>(data, raw)) {
 		throw errors.new(`rec ${name}: handle construction incomplete`)
 	}
 	return raw
@@ -172,15 +181,16 @@ function makeRec<Rels extends SchemaRelations, Name extends string, P extends Pa
  * the one `ProgramIr` shape the engine executes under the per-stratum
  * fixpoint driver.
  */
-function program<Rels extends SchemaRelations, Q extends Query<Rels, unknown, ParamsRecord>>(
-	theory: Schema<Rels>,
-	build: (p: ProgramScope<Rels>) => Q
-): Q {
-	const state: ProgramState = { recs: [], sealed: false }
+function program<
+	Rels extends SchemaRelations,
+	Classes extends SchemaClasses,
+	Q extends Query<Rels, unknown, ParamsRecord, Classes>
+>(theory: Schema<Rels, Classes>, build: (p: ProgramScope<Rels, Classes>) => Q): Q {
+	const state: ProgramState = { recs: [], classes: theory.classes, sealed: false }
 	const names = new Set<string>()
 	const made: { query: unknown } = { query: undefined }
-	const scope: ProgramScope<Rels> = {
-		rec<const Name extends string>(name: Name): Rec<Rels, Name, Record<never, never>> {
+	const scope: ProgramScope<Rels, Classes> = {
+		rec<const Name extends string>(name: Name): Rec<Rels, Name, Record<never, never>, undefined, Classes> {
 			if (state.sealed) {
 				throw errors.new(`program: the output is already declared — rec ${name} would be unreachable`)
 			}
@@ -192,11 +202,11 @@ function program<Rels extends SchemaRelations, Q extends Query<Rels, unknown, Pa
 			names.add(name)
 			const data: RecData = { name, rules: [] }
 			state.recs.push(data)
-			return makeRec<Rels, Name, Record<never, never>>(state, name, data)
+			return makeRec<Rels, Name, Record<never, never>, Classes>(state, name, data)
 		},
-		output<const Builds extends readonly OutputBuild<Rels>[]>(
+		output<const Builds extends readonly OutputBuild<Rels, Classes>[]>(
 			...builds: Builds
-		): Query<Rels, OutputRow<Builds>, OutputParams<Builds>> {
+		): Query<Rels, OutputRow<Builds>, OutputParams<Builds>, Classes> {
 			if (state.sealed) {
 				throw errors.new("program: output is declared once — multiple rules are multiple builds of the one output")
 			}
@@ -213,9 +223,9 @@ function program<Rels extends SchemaRelations, Q extends Query<Rels, unknown, Pa
 				throw errors.new("program: the output needs at least one rule")
 			}
 			const rules = builds.map(function buildRule(buildOne) {
-				return buildOne(makeOutputRuleScope<Rels>(state)).rule
+				return buildOne(makeOutputRuleScope<Rels, Classes>(state)).rule
 			})
-			const q = makeQuery<Rels, OutputRow<Builds>, OutputParams<Builds>>(theory, state.recs, rules)
+			const q = makeQuery<Rels, OutputRow<Builds>, OutputParams<Builds>, Classes>(theory, state.recs, rules)
 			made.query = q
 			return q
 		}

package/src/query/scope.ts

@@ -1,21 +1,25 @@
 /**
- * Query scope terms, STRUCTURAL edition: string-named variables and
+ * Query scope terms, LAW-TYPED edition: string-named variables and
  * parameters as plain frozen values. A `Var` is a NAME — it is typed by the
- * field it first binds (structurally, off the schema type, through the rule
- * builder's environment), reuse of the name within one rule IS the join,
- * and a domain-mismatched reuse is a compile error (the structural analog
- * of the old brand-equal join — now domain-equal, no value brands
- * anywhere). Params are query-global by name and typed BY USE: the field
- * position or comparison sibling that anchors a param types it, the
- * query's inferred `Params` object is exactly the params the rules use,
- * and a param value that no rule uses simply never registers — the query
- * executes under its own inferred type (the bug-hunt law). This module
- * also owns the environment/typing utilities the whole surface shares:
- * the env shape (var name → field descriptor), the domain-equality
- * judgment, and the record-folding helpers `Params` and `Row` inference
- * ride.
+ * field slot it first binds (the descriptor AND the slot's law-computed
+ * CLASS, read off the schema's class map through the rule builder's
+ * environment), reuse of the name within one rule IS the join, and a
+ * class-mismatched reuse is a compile error: a var joins only class-equal
+ * slots, and BARE PAIRS ONLY WITH BARE (ruling 3 — a slot in no law has no
+ * class and never joins a classed slot; the deliberate sum-domain pointer
+ * stays legal against other bare slots). Params are query-global by name
+ * and typed BY USE: the field position or comparison sibling that anchors
+ * a param types it, the query's inferred `Params` object is exactly the
+ * params the rules use, and a param value that no rule uses simply never
+ * registers — the query executes under its own inferred type (the
+ * bug-hunt law). This module also owns the environment/typing utilities
+ * the whole surface shares: the env shape (var name → classed slot), the
+ * class-equality judgment {@link JoinOk} with its runtime twin
+ * {@link fieldJoins}, and the record-folding helpers `Params` and `Row`
+ * inference ride.
  */
 
+import * as errors from "@superbuilders/errors"
 import type { AnyField, Infer } from "#fields.ts"
 
 /**
@@ -106,6 +110,57 @@ function makeVar<const Name extends string>(name: Name): Var<Name> {
 	return Object.freeze(value)
 }
 
+/** The record `makeVars` mints: one own frozen `Var<Name>` per requested name, each typed exactly. */
+type VarsRecord<Names extends string> = { readonly [N in Names]: Var<N> }
+
+/**
+ * The trusted seam of the vars mint: every requested name reads back as an
+ * own var term of exactly that name — verified before the record is
+ * admitted at the {@link VarsRecord} type (a name riding the
+ * object-protocol accessor instead of an own definition would fail exactly
+ * this check).
+ */
+function varsMinted<Names extends string>(
+	record: Readonly<Record<string, unknown>>,
+	names: readonly Names[]
+): record is Readonly<Record<string, unknown>> & VarsRecord<Names> {
+	return names.every(function varMinted(name) {
+		if (!Object.hasOwn(record, name)) {
+			return false
+		}
+		const value = record[name]
+		return isTerm(value) && value[term] === "var" && value.name === name
+	})
+}
+
+/**
+ * Mints several variables at once — `const { service, w } = r.vars("service",
+ * "w")`: tuple-to-object, each name typed exactly (`Var<"service">`),
+ * inference identical to the one-at-a-time `r.var` spelling (one lowering,
+ * two entry flavors). Each key is defined as an OWN property (a name like
+ * `"__proto__"` is a record key like any other, never a prototype write),
+ * and a duplicate name in one call is a construction error: each name mints
+ * one variable — write it once and reuse the binding.
+ */
+function makeVars<const Names extends readonly string[]>(...names: Names): VarsRecord<Names[number]> {
+	const out: Record<string, unknown> = {}
+	const seen = new Set<string>()
+	for (const name of names) {
+		if (seen.has(name)) {
+			throw errors.new(
+				`vars: duplicate name ${name} — each name mints one variable; write it once and reuse the binding`
+			)
+		}
+		seen.add(name)
+		Object.defineProperty(out, name, { value: makeVar(name), enumerable: true })
+	}
+	Object.freeze(out)
+	if (!varsMinted<Names[number]>(out, names)) {
+		throw errors.new("vars: variable minting incomplete")
+	}
+	return out
+}
+
 /** Builds one scalar-parameter term. */
 function makeParam<const Name extends string>(name: Name): Param<Name> {
 	const value: Param<Name> = { [term]: "param", name }
@@ -131,11 +186,24 @@ function makeDuration<const Name extends string>(name: Name): Duration<Name> {
 }
 
 /**
- * A rule's typing environment: variable name → the field descriptor it
- * first bound. Purely a TYPE — the runtime twin is the rule's `varFields`
+ * One bound field slot: the field's descriptor plus the slot's
+ * law-computed CLASS (`undefined` = bare — the slot is in no law). The one
+ * shape the rule environment carries per variable, at the TYPE level (env
+ * entries hold the schema type's class-map lookups) and at RUNTIME alike
+ * (the rule's `varFields` record holds exactly this shape, read off the
+ * schema value's frozen class map) — one shape, two tiers, one walk.
+ */
+interface ClassedField {
+	readonly field: AnyField
+	readonly class: string | undefined
+}
+
+/**
+ * A rule's typing environment: variable name → the classed slot it first
+ * bound. Purely a TYPE — the runtime twin is the rule's `varFields`
  * record, and the two are built by the same walk.
  */
-type EnvShape = Record<string, AnyField>
+type EnvShape = Record<string, ClassedField>
 
 /** A params object type — what `execute` takes and inference carries. */
 type ParamsRecord = Readonly<Record<string, unknown>>
@@ -154,9 +222,6 @@ type UnionToIntersection<U> = (U extends unknown ? (member: U) => void : never)
  */
 type ShapeOf<U> = [U] extends [never] ? Record<never, never> : Flatten<UnionToIntersection<U>>
 
-/** Reads a field descriptor's domain label (S1: the label IS the domain check). */
-type DomainOf<F extends AnyField> = F["domain"]
-
 /** Reads a field descriptor's width label (`bytes<N>`, `interval<E, W>`); `undefined` when the kind carries none. */
 type WidthOf<F extends AnyField> = F extends { readonly width: infer W } ? W : undefined
 
@@ -164,43 +229,52 @@ type WidthOf<F extends AnyField> = F extends { readonly width: infer W } ? W : u
 type ElementOf<F extends AnyField> = F extends { readonly element: infer E } ? E : undefined
 
 /**
- * The structural join judgment: two field descriptors join iff kind,
- * domain label, width label, and interval element all agree — the
- * string-literal comparison of descriptor shapes that replaced the value
- * brand (design ruling 3).
+ * The join judgment: two bound slots join iff their descriptors' structure
+ * agrees (kind, width label, interval element) AND their law-computed
+ * classes agree — same class name joins, and bare (`undefined`) pairs only
+ * with bare (ruling 3: a field in no law has no class; a bare↔classed
+ * pairing refuses). The class names come off the SCHEMA type's class map —
+ * the statements are the typing; no descriptor label exists to compare.
  */
-type JoinOk<A extends AnyField, B extends AnyField> = [A["kind"], DomainOf<A>, WidthOf<A>, ElementOf<A>] extends [
-	B["kind"],
-	DomainOf<B>,
-	WidthOf<B>,
-	ElementOf<B>
-]
-	? [B["kind"], DomainOf<B>, WidthOf<B>, ElementOf<B>] extends [A["kind"], DomainOf<A>, WidthOf<A>, ElementOf<A>]
+type JoinOk<A extends ClassedField, B extends ClassedField> = [
+	A["field"]["kind"],
+	A["class"],
+	WidthOf<A["field"]>,
+	ElementOf<A["field"]>
+] extends [B["field"]["kind"], B["class"], WidthOf<B["field"]>, ElementOf<B["field"]>]
+	? [B["field"]["kind"], B["class"], WidthOf<B["field"]>, ElementOf<B["field"]>] extends [
+			A["field"]["kind"],
+			A["class"],
+			WidthOf<A["field"]>,
+			ElementOf<A["field"]>
+		]
 		? true
 		: false
 	: false
 
 /**
- * The runtime twin of {@link JoinOk}: two field descriptors join iff kind,
- * domain label, width label, and interval element all agree — the same
- * structural comparison the type tier makes, judged on the descriptor
- * VALUES (S1 descriptors are honest at runtime). The rule builders throw
- * through this on a domain-unequal variable reuse, so the wall holds for
- * untyped callers too, not only where the compiler can see.
+ * The runtime twin of {@link JoinOk}: two bound slots join iff descriptor
+ * structure and class agree — the same comparison the type tier makes,
+ * judged on the honest runtime values (the descriptor and the schema
+ * value's frozen class map). The rule builders throw through this on a
+ * class-unequal variable reuse, so the wall holds for untyped callers too,
+ * not only where the compiler can see.
  */
-function fieldJoins(a: AnyField, b: AnyField): boolean {
-	const widthA = "width" in a ? a.width : undefined
-	const widthB = "width" in b ? b.width : undefined
-	const elementA = "element" in a ? a.element : undefined
-	const elementB = "element" in b ? b.element : undefined
-	return a.kind === b.kind && a.domain === b.domain && widthA === widthB && elementA === elementB
+function fieldJoins(a: ClassedField, b: ClassedField): boolean {
+	const widthA = "width" in a.field ? a.field.width : undefined
+	const widthB = "width" in b.field ? b.field.width : undefined
+	const elementA = "element" in a.field ? a.field.element : undefined
+	const elementB = "element" in b.field ? b.field.element : undefined
+	return a.field.kind === b.field.kind && a.class === b.class && widthA === widthB && elementA === elementB
 }
 
 /**
- * Renders one field descriptor for join-mismatch diagnostics — the schema
- * grammar's own spelling (`u64 as HolderId`, `interval<i64, 7> as Window`).
+ * Renders one bound slot for join-mismatch diagnostics — the structural
+ * kind in the schema grammar's spelling plus the slot's law-computed class
+ * (`u64 in class Holder.id`; a lawless slot renders `bare`).
  */
-function renderFieldKind(field: AnyField): string {
+function renderFieldKind(slot: ClassedField): string {
+	const field = slot.field
 	let base: string = field.kind
 	if (field.kind === "bytes") {
 		base = `bytes<${field.width}>`
@@ -208,7 +282,7 @@ function renderFieldKind(field: AnyField): string {
 	if (field.kind === "interval") {
 		base = field.width === undefined ? `interval<${field.element}>` : `interval<${field.element}, ${field.width}>`
 	}
-	return field.domain === undefined ? base : `${base} as ${field.domain}`
+	return slot.class === undefined ? `${base} (bare)` : `${base} in class ${slot.class}`
 }
 
 /**
@@ -241,7 +315,7 @@ interface ParamEntry {
 
 export type {
 	AnyTerm,
-	DomainOf,
+	ClassedField,
 	Duration,
 	EnvShape,
 	Flatten,
@@ -255,7 +329,8 @@ export type {
 	SetParam,
 	ShapeOf,
 	UnionToIntersection,
-	Var
+	Var,
+	VarsRecord
 }
 export {
 	fieldJoins,
@@ -266,6 +341,7 @@ export {
 	makeParam,
 	makeSetParam,
 	makeVar,
+	makeVars,
 	renderFieldKind,
 	term
 }

package/src/query/select.ts

@@ -166,7 +166,7 @@ type CheckNameSelect<Env extends EnvShape, S> = {
  * type.
  */
 type SelectEntryRow<Env extends EnvShape, E> = E extends string
-	? { readonly [K in E]: Infer<Env[E & keyof Env]> }
+	? { 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>
@@ -175,14 +175,14 @@ type SelectEntryRow<Env extends EnvShape, E> = E 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]> }
+						? { 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]> }
+						? { 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]> }
+							? { readonly [K in O]: Infer<Env[O & keyof Env]["field"]> }
 							: never
 
 /** The inferred answer-row object type of a select tuple. */
@@ -194,7 +194,7 @@ type RowOfSelect<Env extends EnvShape, S extends readonly SelectEntry[]> = Shape
  * 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]> }
+	? { 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. */

package/src/relation.ts

@@ -57,7 +57,10 @@ function resolveEntry(field: AnyField, entry: unknown): LiteralSetSpec {
  * Resolves a whole `where()` selection against the declared fields, in the
  * selection's written order (macro parity: σ is spelled, not sorted). An
  * empty selection is the bare relation respelled and rejected (the
- * canonical-utterance law).
+ * canonical-utterance law). THE one selection resolver — `closed()`'s
+ * `where()` resolves its payload columns through this same machine (a
+ * `ClosedColumn` is structurally a {@link RelationField}), so both surfaces
+ * share one vocabulary and one error voice.
  */
 function resolveSelection(
 	name: string,
@@ -91,8 +94,8 @@ type FieldsShape = Record<string, AnyField>
 /**
  * A typed field reference (`Account.fields.holder`) — the value statements,
  * selections, and queries address a field through. Purely positional
- * (relation name + field name); the field's descriptor (domain label
- * included) is read off the relation's schema type structurally.
+ * (relation name + field name); the field's descriptor is read off the
+ * relation's schema type structurally.
  */
 interface FieldRef<Rel extends string, Name extends string> {
 	readonly relation: Rel
@@ -186,11 +189,14 @@ type FreshKeys<R extends AnyRelation> = {
 type InsertFact<R extends AnyRelation> = Flatten<Omit<Fact<R>, FreshKeys<R>> & Partial<Pick<Fact<R>, FreshKeys<R>>>>
 
 /**
- * Declares one relation: `relation("Account", { id: AccountId.fresh,
- * holder: HolderId, ... })` — every field references a declared
- * domain-labeled descriptor (`const AccountId = u64.as("AccountId")`) or a
- * bare constructor. Field declaration order is ordinal-id order (macro
- * parity); the returned value is frozen and side-effect free.
+ * Declares one relation: `relation("Account", { id: u64.fresh,
+ * holder: u64, kind: Kind.id, ... })` — every field is a pure-structure
+ * descriptor (the constructor values themselves; domains are never
+ * declared: `schema()` computes them from the statements). Field
+ * declaration order is ordinal-id order (macro parity), carried at BOTH
+ * levels: the type level by the fields object, the value level by the
+ * frozen `data.fields` list — the law the schema-level class naming leans
+ * on. The returned value is frozen and side-effect free.
  */
 function relation<const Name extends string, Fields extends FieldsShape>(
 	name: Name,
@@ -243,4 +249,4 @@ export type {
 	SelectionBinding,
 	SelectionInput
 }
-export { relation }
+export { relation, resolveSelection }

package/src/schema.ts

@@ -13,6 +13,7 @@ import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import type { FaceData } from "#face.ts"
 import { type AnyField, assertDeclarationOrderKey, type ClosedRoster } 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"
@@ -128,7 +129,7 @@ function verifyBindingHandles(
 		}
 		if (roster === undefined) {
 			throw errors.new(
-				`schema ${name}: ${face.owner.name}.${binding.field} is not a closed-relation reference — the handle literal ${literal.handle} is legal only on a field whose domain is a closed relation's handle domain — ${rendered}`
+				`schema ${name}: ${face.owner.name}.${binding.field} is not a closed-relation reference — the handle literal ${literal.handle} is legal only on a field carrying a closed relation's roster — ${rendered}`
 			)
 		}
 		if (!roster.handles.includes(literal.handle)) {
@@ -247,16 +248,43 @@ type SchemaRelation = AnyRelation | AnyClosed
 /** The relation record a schema is generic over — what `Db` and queries key on. */
 type SchemaRelations = Record<string, SchemaRelation>
 
-/** A theory value: named relations plus the DECLARED dependency statements. */
-interface Schema<Rels extends SchemaRelations> {
+/**
+ * A theory value: named relations, the DECLARED dependency statements, and
+ * the LAW-COMPUTED class map (`classes` — relation → field → class name,
+ * `undefined` = bare). The class map is THE domain authority: `schema()`
+ * computes it FROM the statement list at both tiers (the type through
+ * {@link ClassesOf}, the value through the union-find twin), queries
+ * compare class names off it, and the wire lowering emits it as the spec
+ * `newtype` labels. Nothing is ever synthesized: `statements` is exactly
+ * the declared list, in written order.
+ */
+interface Schema<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> {
 	readonly name: string
 	readonly relations: Rels
 	readonly statements: readonly Statement[]
+	readonly classes: Classes
 }
 
 /** Any schema value, whatever its relation record. */
 type AnySchema = Schema<SchemaRelations>
 
+/**
+ * Forces the class map to EVALUATE at the `schema()` boundary: a two-level
+ * mapped copy, type-identical to `C` — but instantiation resolves it to
+ * the finished relation → field → class record, so hovering a schema value
+ * (or anything carrying its `Classes` parameter — queries, `Db`) shows the
+ * computed record instead of the unevaluated `ClassesOf<...>` application
+ * dragging the whole statement-tuple type along. The conditional wrapper
+ * is the display mechanism, not a judgment: resolving it drops the alias
+ * reference, so tsc renders the finished record (measured against tsc's
+ * own type rendering; a bare mapped alias still displays by name).
+ * Display-only by construction; `classesComplete` guards the same type at
+ * the value tier.
+ */
+type EvaluatedClasses<C extends SchemaClasses> = C extends SchemaClasses
+	? { readonly [N in keyof C]: { readonly [F in keyof C[N]]: C[N][F] } }
+	: never
+
 /**
  * Assembles a theory:
  * `schema("Ledger", { Kind, Account, Holder }, [ ...statements ])`.
@@ -277,12 +305,21 @@ type AnySchema = Schema<SchemaRelations>
  * list: the engine materializes them itself, in its own pinned order
  * (`SchemaDescriptor::materialized_statements`), and restating them would
  * double them.
+ *
+ * THE LAW-TYPING happens here too (rulings 2/3 — the laws type the
+ * columns): the statement list induces the equivalence classes over field
+ * slots, at the TYPE level ({@link ClassesOf} — spell the statement list
+ * inline so the tuple type stays precise) and at runtime (the union-find
+ * twin), and the one-generator-per-class wall holds at both tiers — the
+ * {@link LawfulStatements} verdict lands the compile error on the
+ * statements argument; `computeClasses` throws the same content naming the
+ * exact statement.
  */
-function schema<const Rels extends SchemaRelations>(
+function schema<const Rels extends SchemaRelations, const Stmts extends readonly Statement[]>(
 	name: string,
 	relations: Rels,
-	statements: readonly Statement[]
-): Schema<Rels> {
+	statements: Stmts & LawfulStatements<Rels, Stmts>
+): Schema<Rels, EvaluatedClasses<ClassesOf<Rels, Stmts>>> {
 	const implied = collectImplied(name, relations)
 	const seen = new Set<string>()
 	for (const statement of statements) {
@@ -300,7 +337,11 @@ function schema<const Rels extends SchemaRelations>(
 		verifyHandles(name, statement, rendered)
 	}
 	verifyClosedReferences(name, statements)
-	return Object.freeze({ name, relations, statements: Object.freeze([...statements]) })
+	const classes = computeClasses(name, relations, statements)
+	if (!classesComplete<EvaluatedClasses<ClassesOf<Rels, Stmts>>>(classes, relations)) {
+		throw errors.new(`schema ${name}: class-map construction incomplete`)
+	}
+	return Object.freeze({ name, relations, statements: Object.freeze([...statements]), classes })
 }
 
 export type { AnySchema, Schema, SchemaRelation, SchemaRelations }

package/src/spec.ts

@@ -95,10 +95,10 @@ type WindowSpec =
 	| { readonly kind: "floor"; readonly lo: bigint }
 
 /**
- * One field: name, structural type, host newtype name — the descriptor's
- * DOMAIN label (the macro's `as NewType`; the SDK's `.as("Domain")`),
- * carried for handle resolution only, dropped by the engine at descriptor
- * lowering and never fingerprinted — and the `fresh` mint mark.
+ * One field: name, structural type, host newtype name — the field's
+ * DOMAIN (the macro's declared `as NewType`; the SDK's law-computed class
+ * name), carried for handle resolution only, dropped by the engine at
+ * descriptor lowering and never fingerprinted — and the `fresh` mint mark.
  */
 interface FieldSpec {
 	readonly name: string
@@ -121,8 +121,9 @@ interface RowSpec {
  * 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 its handle DOMAIN, `` `${name}Id` `` — the same
- * label every referencing field carries), undefined on an ordinary one.
+ * 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.
  */
 interface RelationSpec {
 	readonly name: string