@bjornpagen/bumbledb 0.3.0 → 0.4.0

package/COOKBOOK.md

@@ -33,6 +33,7 @@ Everything below imports from the one package entry:
 import {
 	ALLEN,
 	Db,
+	type Infer,
 	abandon,
 	allen,
 	bool,
@@ -150,8 +151,8 @@ relations, glued by bidirectional conditional containments.
 
 ```ts
 // The discriminator vocabulary is a closed relation: its ground axioms are
-// axioms, and the handle constants (`Kind.Deterministic`, bare bigints) are
-// the literals on every surface.
+// axioms, and a handle is its NAME — the string literal "Deterministic" is
+// the ONE spelling, on every surface (statements, inserts, queries, rows).
 const Kind = closed("Kind", ["Deterministic", "CustomOperator"])
 const Task = relation("Task", { id: u64.fresh, kind: Kind.id })
 const DeterministicGrading = relation("DeterministicGrading", { task: u64, tolerance: i64 })
@@ -166,21 +167,28 @@ const Grading = schema("Grading", { Kind, Task, DeterministicGrading, CustomOper
 	// exists WITH that kind — composite-FK-plus-CHECK, one statement. These
 	// mirrors are also what type `task` on both arms: each lands in the
 	// "Task.id" generator class.
-	mirrors(on(Task.where({ kind: Kind.Deterministic }), "id"), on(DeterministicGrading, "task")),
-	mirrors(on(Task.where({ kind: Kind.CustomOperator }), "id"), on(CustomOperatorGrading, "task"))
+	mirrors(on(Task.where({ kind: "Deterministic" }), "id"), on(DeterministicGrading, "task")),
+	mirrors(on(Task.where({ kind: "CustomOperator" }), "id"), on(CustomOperatorGrading, "task"))
 	// Exclusivity is a theorem, not a statement: one id in two arms would
 	// force `kind` to equal two handles against the fresh key on id.
 	// The executor spends the same theorem again — recipe 22's free lunch.
 ])
 
-// Host dispatch over the discriminator is `match` — exhaustive over the
-// sealed roster by construction (a missing arm is a compile error; an
-// out-of-roster id throws, never misdispatches):
-const gradedBy = (kind: bigint) =>
-	Kind.match(kind, {
-		Deterministic: () => "tolerance",
-		CustomOperator: () => "operator"
-	})
+// Host dispatch over the discriminator is native `switch` narrowing over
+// the handle union (`Infer<typeof Kind.id>` = "Deterministic" |
+// "CustomOperator") — rows already arrive carrying the handle name, and
+// `satisfies never` makes the switch exhaustive: a missing arm is a
+// compile error.
+const gradedBy = (kind: Infer<typeof Kind.id>) => {
+	switch (kind) {
+		case "Deterministic":
+			return "tolerance"
+		case "CustomOperator":
+			return "operator"
+		default:
+			return kind satisfies never
+	}
+}
 ```
 
 ## 3. 0..1 optional attributes
@@ -301,13 +309,13 @@ declared priority handles.
 The enum idiom's replacement, first-class: a vocabulary is a **closed
 relation** — its ground axioms are declared in the schema, sealed at
 validate, frozen by the fingerprint, virtual in storage. The store holds zero
-vocabulary bytes, and handles are the literals on every surface.
+vocabulary bytes, and handle names are the string literals on every surface.
 
 ```ts
-// Tier 1: handles only. `closed()` mints one bare-bigint constant per handle
-// (ids = declaration order) — an emission, not a type: the engine's
-// vocabulary stays relational; the host matches on `Priority.Urgent`, or
-// dispatches exhaustively with `Priority.match` (recipe 2).
+// Tier 1: handles only. At the host surface a handle is its NAME — a string
+// literal of the roster's union ("Low" | "Normal" | "Urgent"); the engine's
+// vocabulary stays relational (ids = declaration order) and the marshal
+// owns the bijection. Dispatch is native `switch` narrowing (recipe 2).
 const Priority = closed("Priority", ["Low", "Normal", "Urgent"])
 
 const Ticket = relation("Ticket", { id: u64.fresh, priority: Priority.id, opened_at: i64 })
@@ -327,7 +335,16 @@ const Tickets = schema("Tickets", { Priority, Ticket }, [
 // never written, only declared.
 const urgent = query(Tickets).rule((r) => {
 	const { t } = r.vars("t")
-	return r.match(Ticket, { id: t, priority: Priority.Urgent }).select("t")
+	return r.match(Ticket, { id: t, priority: "Urgent" }).select("t")
+})
+
+// Set membership is a plain array — the drizzle law's spelling, closed-only
+// in query match records (an ordinary u64/str field's membership is a bound
+// ∈-set param, `r.inSet`); the array folds to the same wire set the param
+// spelling crosses. In `.where()` selections arrays work at EVERY field kind.
+const actionable = query(Tickets).rule((r) => {
+	const { t } = r.vars("t")
+	return r.match(Ticket, { id: t, priority: ["Normal", "Urgent"] }).select("t")
 })
 ```
 
@@ -378,13 +395,16 @@ const masteredAttempts = query(Review).rule((r) => {
 		.select("a")
 })
 
-// Host dispatch on the payload tier hands each arm its sealed axiom row:
-const label = (k: bigint) =>
-	Kind.match(k, {
-		DirectPass: (row) => `mastered, rank ${row.rank}`,
-		JudgedPass: (row) => `mastered, rank ${row.rank}`,
-		Failed: () => "not mastered"
-	})
+// Host dispatch on the payload tier is the record-table idiom — a `Record`
+// over the handle union is total by type (a missing or extra entry is a
+// compile error), and each entry reads its sealed axiom row off the typed
+// `Kind.axioms` readback:
+const labels: Record<Infer<typeof Kind.id>, string> = {
+	DirectPass: `mastered, rank ${Kind.axioms.DirectPass.rank}`,
+	JudgedPass: `mastered, rank ${Kind.axioms.JudgedPass.rank}`,
+	Failed: "not mastered"
+}
+const label = (k: Infer<typeof Kind.id>) => labels[k]
 ```
 
 Two honest boundaries. The fold has limits: payload escaping to the head and
@@ -425,7 +445,7 @@ const Oncall = schema("Oncall", { Severity, Incident, Escalation }, [
 	// The sub-vocabulary: an escalation carries a PAGING severity, by
 	// statement. ψ over the sealed extension compiles to the member set
 	// {Critical, Fatal}; the judgment is one bit test per touched fact,
-	// and an escalation at Severity.Info aborts the commit.
+	// and an escalation at "Info" aborts the commit.
 	contained(on(Escalation, "severity"), on(Severity.where({ pages: true }), "id"))
 ])
 
@@ -512,8 +532,8 @@ const Ast = schema("Ast", { Kind, Node, Lit, Add, Parent }, [
 	key(Lit, ["node"]),
 	key(Add, ["node"]),
 	// Every node's arm is total, valid, and exclusive (recipe 2's theorems):
-	mirrors(on(Node.where({ kind: Kind.Lit }), "id"), on(Lit, "node")),
-	mirrors(on(Node.where({ kind: Kind.Add }), "id"), on(Add, "node")),
+	mirrors(on(Node.where({ kind: "Lit" }), "id"), on(Lit, "node")),
+	mirrors(on(Node.where({ kind: "Add" }), "id"), on(Add, "node")),
 	// Every child edge resolves — no dangling subtrees, judged at commit
 	// (these containments also put lhs/rhs in the "Node.id" class, which is
 	// exactly what lets the query below join lhs against Lit.node):
@@ -635,7 +655,7 @@ const Orders = schema("Orders", { State, Order, Placement, Shipment }, [
 	// The conditional target, both ways: every Shipment references an order
 	// THAT IS Shipped (validity), and every Shipped order has its Shipment
 	// (totality) — the transition and its evidence commit together.
-	mirrors(on(Shipment, "order"), on(Order.where({ state: State.Shipped }), "id"))
+	mirrors(on(Shipment, "order"), on(Order.where({ state: "Shipped" }), "id"))
 	// Transition predicates ("only Placed may ship") are host code under the
 	// generation witness — recipe 20; the schema pins the states, not the paths.
 ])
@@ -643,7 +663,7 @@ const Orders = schema("Orders", { State, Order, Placement, Shipment }, [
 const shipped = query(Orders).rule((r) => {
 	const { id, carrier } = r.vars("id", "carrier")
 	return r
-		.match(Order, { id, state: State.Shipped })
+		.match(Order, { id, state: "Shipped" })
 		.match(Shipment, { order: id, carrier })
 		.select("id", "carrier")
 })
@@ -701,11 +721,11 @@ const Calendar = schema("Calendar", { Rsvp, Arm, Person, Room, Event, Attendance
 	// not declared. Policy is the presence or absence of one statement.
 	// Accepting an invitation IS claiming the time (totality + validity) —
 	// and this is the statement that types Claim.source:
-	mirrors(on(Attendance.where({ rsvp: Rsvp.Accepted }), "id"), on(Claim.where({ arm: Arm.Busy }), "source")),
+	mirrors(on(Attendance.where({ rsvp: "Accepted" }), "id"), on(Claim.where({ arm: "Busy" }), "source")),
 	// Busy time lies inside working hours, pointwise — coverage rides the
 	// target's own key (disjoint + ordered is a theorem, not a request):
 	key(WorkHours, ["person", "hours"]),
-	contained(on(Claim.where({ arm: Arm.Busy }), ["person", "span"]), on(WorkHours, ["person", "hours"])),
+	contained(on(Claim.where({ arm: "Busy" }), ["person", "span"]), on(WorkHours, ["person", "hours"])),
 	contained(on(Booking, "room"), on(Room, "id")),
 	contained(on(Booking, "event"), on(Event, "id"))
 ])
@@ -953,13 +973,13 @@ const Jobs = schema("Jobs", { State, Job, Lease }, [
 	key(Lease, ["job"]),
 	// A lease exists iff its job is Running (recipe 13's conditional target):
 	// claiming a job and leasing it commit together or not at all.
-	mirrors(on(Lease, "job"), on(Job.where({ state: State.Running }), "id"))
+	mirrors(on(Lease, "job"), on(Job.where({ state: "Running" }), "id"))
 ])
 
 // update-where's premise — "still Queued" is the witness:
 const stillQueued = query(Jobs).rule((r) => {
 	const { id, payload } = r.vars("id", "payload")
-	return r.match(Job, { id, state: State.Queued, payload }).select("id", "payload")
+	return r.match(Job, { id, state: "Queued", payload }).select("id", "payload")
 })
 
 const db = await Db.create("./jobs.db", Jobs)
@@ -976,8 +996,8 @@ const outcome = db.writeWitnessed(function updateWhere(snap, tx) {
 		return abandon("nothing queued")
 	}
 	for (const row of queued) {
-		tx.delete(Job, { id: row.id, state: State.Queued, payload: row.payload })
-		tx.insert(Job, { id: row.id, state: State.Running, payload: row.payload })
+		tx.delete(Job, { id: row.id, state: "Queued", payload: row.payload })
+		tx.insert(Job, { id: row.id, state: "Running", payload: row.payload })
 		tx.insert(Lease, { job: row.id, worker: 7n, until: 60n })
 	}
 	return undefined
@@ -1007,7 +1027,7 @@ const Rollup = schema("Rollup", { Arm, Claim, BusySpan }, [
 	// Soundness, pointwise: every stored rollup point is covered by busy
 	// claims — an UNSOUND rollup (claiming busy time that isn't, or surviving
 	// its sources' deletion) cannot commit, judged on every touching commit.
-	contained(on(BusySpan, ["person", "span"]), on(Claim.where({ arm: Arm.Busy }), ["person", "span"]))
+	contained(on(BusySpan, ["person", "span"]), on(Claim.where({ arm: "Busy" }), ["person", "span"]))
 ])
 
 // Maintenance is the third witness idiom (recipe 20): re-run the deriving
@@ -1016,7 +1036,7 @@ const Rollup = schema("Rollup", { Arm, Claim, BusySpan }, [
 // coalesce):
 const deriving = query(Rollup).rule((r) => {
 	const { person, span } = r.vars("person", "span")
-	return r.match(Claim, { person, span, arm: Arm.Busy }).select("person", r.pack("span"))
+	return r.match(Claim, { person, span, arm: "Busy" }).select("person", r.pack("span"))
 })
 ```
 
@@ -1040,8 +1060,8 @@ const Payments = schema("Payments", { Kind, Payment, Card, Ach }, [
 	contained(on(Payment, "kind"), on(Kind, "id")),
 	key(Card, ["payment"]),
 	key(Ach, ["payment"]),
-	mirrors(on(Payment.where({ kind: Kind.Card }), "id"), on(Card, "payment")),
-	mirrors(on(Payment.where({ kind: Kind.Ach }), "id"), on(Ach, "payment"))
+	mirrors(on(Payment.where({ kind: "Card" }), "id"), on(Card, "payment")),
+	mirrors(on(Payment.where({ kind: "Ach" }), "id"), on(Ach, "payment"))
 ])
 
 // One query, two rules (set union). The exclusivity theorem (recipe 2) is
@@ -1051,14 +1071,14 @@ const wholeDu = query(Payments)
 	.rule((r) => {
 		const { id, n } = r.vars("id", "n")
 		return r
-			.match(Payment, { id, kind: Kind.Card })
+			.match(Payment, { id, kind: "Card" })
 			.match(Card, { payment: id, last4: n })
 			.select("id", "n")
 	})
 	.rule((r) => {
 		const { id, n } = r.vars("id", "n")
 		return r
-			.match(Payment, { id, kind: Kind.Ach })
+			.match(Payment, { id, kind: "Ach" })
 			.match(Ach, { payment: id, routing: n })
 			.select("id", "n")
 	})
@@ -1323,13 +1343,13 @@ const MaintainedRollup = schema("MaintainedRollup", { Arm, Claim, BusySpan }, [
 	key(Claim, ["source"]),
 	key(Claim, ["person", "span"]),
 	key(BusySpan, ["person", "span"]),
-	contained(on(BusySpan, ["person", "span"]), on(Claim.where({ arm: Arm.Busy }), ["person", "span"]))
+	contained(on(BusySpan, ["person", "span"]), on(Claim.where({ arm: "Busy" }), ["person", "span"]))
 ])
 
 // Derive the desired rollup on the maintenance snapshot:
 const deriving = query(MaintainedRollup).rule((r) => {
 	const { source, person, span } = r.vars("source", "person", "span")
-	return r.match(Claim, { source, person, arm: Arm.Busy, span }).select("person", r.pack("span"))
+	return r.match(Claim, { source, person, arm: "Busy", span }).select("person", r.pack("span"))
 })
 ```
 
@@ -1437,8 +1457,8 @@ const ZoneLedger = schema("ZoneLedger", { Kind, Ledger, Zone, UnitSlot, PairSlot
 	key(PairSlot, ["ledger", "at"]),
 	// Each kind's zones carry exactly its sidecar's points — mixed widths,
 	// one element domain:
-	mirrors(on(Zone.where({ kind: Kind.Unit }), ["ledger", "at"]), on(UnitSlot, ["ledger", "at"])),
-	mirrors(on(Zone.where({ kind: Kind.Pair }), ["ledger", "at"]), on(PairSlot, ["ledger", "at"]))
+	mirrors(on(Zone.where({ kind: "Unit" }), ["ledger", "at"]), on(UnitSlot, ["ledger", "at"])),
+	mirrors(on(Zone.where({ kind: "Pair" }), ["ledger", "at"]), on(PairSlot, ["ledger", "at"]))
 ])
 ```
 

package/README.md

@@ -27,9 +27,11 @@ classes, inferred query rows, and rejections that arrive as data rather than
 exceptions.
 
 ```ts
-import { bool, closed, contained, Db, gt, key, on, query, relation, schema, u64 } from "@bjornpagen/bumbledb"
+import { bool, closed, contained, Db, gt, type Infer, key, on, query, relation, schema, u64 } from "@bjornpagen/bumbledb"
 
 // A closed relation: a sealed roster of axioms with typed payload columns.
+// At the host surface a handle is its NAME — the string literal "DirectPass"
+// is the one spelling, and closed columns type as the handle union.
 const Kind = closed(
 	"Kind",
 	{ mastered: bool, rank: u64 },
@@ -57,10 +59,12 @@ const Review = schema("Review", { Kind, Attempt, Certificate }, [
 
 const db = await Db.create("./review.db", Review)
 
-// Write. The delta is judged against every statement at commit.
+// Write. The delta is judged against every statement at commit. A closed
+// column takes the handle name — a wrong string is a compile error AND a
+// marshal refusal.
 const result = db.write((tx) => {
-	const attempt = tx.insert(Attempt, { kind: Kind.DirectPass }) // attempt.id minted, a bare bigint
-	tx.insert(Certificate, { attempt: attempt.id, kind: Kind.DirectPass })
+	const attempt = tx.insert(Attempt, { kind: "DirectPass" }) // attempt.id minted, a bare bigint
+	tx.insert(Certificate, { attempt: attempt.id, kind: "DirectPass" })
 })
 
 // Rejection-as-data: no throw — a rejected commit is a typed value carrying
@@ -87,14 +91,21 @@ const prepared = db.prepare(certifiedAbove)
 const rows = db.execute(prepared, { floor: 15n }) // rows: { a: bigint; rank: bigint }[]
 console.log(rows)
 
-// Host dispatch over the sealed roster — exhaustive by construction; each
-// arm receives its axiom row.
-const label = Kind.match(Kind.JudgedPass, {
-	DirectPass: (row) => `mastered, rank ${row.rank}`,
-	JudgedPass: (row) => `mastered, rank ${row.rank}`,
-	Failed: () => "not mastered"
-})
-console.log(label) // "mastered, rank 20"
+// Host dispatch over the sealed roster is native `switch` narrowing over
+// the handle union ("DirectPass" | "JudgedPass" | "Failed") — exhaustive
+// via `satisfies never`; the sealed axioms read back typed.
+function describe(kind: Infer<typeof Kind.id>): string {
+	switch (kind) {
+		case "DirectPass":
+		case "JudgedPass":
+			return `mastered, rank ${Kind.axioms[kind].rank}`
+		case "Failed":
+			return "not mastered"
+		default:
+			return kind satisfies never
+	}
+}
+console.log(describe("JudgedPass")) // "mastered, rank 20"
 ```
 
 Every `ts` fence in this README is extracted and type-checked against the
@@ -102,10 +113,12 @@ real surface by `test/readme.test.ts` — the examples cannot drift.
 
 ## Surface
 
-- The structural type kernel — fields as pure structure (`bool`, `bytes`, `i64`, `u64`, `str`, `interval`, `span`), `relation()`, and `closed()` sealed rosters with typed axiom payloads and exhaustive host dispatch via `.match`. Domains are never declared: `schema()` computes every field's class from the statement list.
-- The statement algebra — `schema()`, `key`, `contained`, `mirrors`, `window`; faces via `on`/`oneOf`; counts via `exactly`, `atLeast`, `atMost`, `between`, `none`; ψ-selection via `.where` on relations and closed rosters.
+The drizzle law governs this surface: the SDK's job at the host boundary is translation, not abstraction — every database idiom arrives as the modern TypeScript idiom for that concept, and the SDK never invents an operator where the language already has one.
+
+- The structural type kernel — fields as pure structure (`bool`, `bytes`, `i64`, `u64`, `str`, `interval`, `span`), `relation()`, and `closed()` sealed rosters with typed axiom payloads. A closed reference's value type IS the handle union (`Infer` speaks it); dispatch is native `switch` narrowing with `satisfies never` exhaustiveness. Domains are never declared: `schema()` computes every field's class from the statement list.
+- The statement algebra — `schema()`, `key`, `contained`, `mirrors`, `window`; faces via `on` (set membership is a plain array in `.where`); counts via `exactly`, `atLeast`, `atMost`, `between`, `none`; ψ-selection via `.where` on relations and closed rosters.
 - The `Db` runtime — `Db.create`/`Db.open`, path-cached stores, transactions, typed violations, scoped snapshot reads, the witnessed write loop with `abandon`.
-- The query surface — Datalog as values, `query(S).rule(r => ...)`: named vars, params typed by use, negation, aggregates, and the free comparison/connective exports (`eq`, `ne`, `lt`, `le`, `gt`, `ge`, `and`, `or`, `not`, `allen`/`ALLEN`, `pointIn`, `covers`); stratified recursion via `program()`; `db.prepare` as a plain value.
+- The query surface — Datalog as values, `query(S).rule(r => ...)`: named vars, params typed by use, negation, aggregates, and the free comparison/connective exports (`eq`, `ne`, `lt`, `le`, `gt`, `ge`, `and`, `or`, `not`, `allen`/`ALLEN`, `pointIn`, `covers`); set membership at a closed field is a plain array in the match record (`r.match(Ticket, { priority: ["Normal", "Urgent"] })` — closed-only there: an ordinary field's membership is a bound `r.inSet` param); stratified recursion via `program()`; `db.prepare` as a plain value.
 - The exhume surface — `Db.exhume`, the schema-independent read path: a store's self-described shapes and raw facts by name, with typed refusals (`ErrExhumeNoDescriptor`, `ErrExhumeFormatMismatch`, `ErrExhumeCorruption`).
 
 ## Cookbook

package/dist/closed.d.ts

@@ -1,34 +1,36 @@
 /**
  * Closed relations (`docs/architecture/10-data-model.md` § closed
  * relations): a vocabulary whose extension is declared in the schema — two
- * tiers, one function. The emission per closed relation mirrors the
- * macro's (host-enum analog): handle CONSTANTS on the value
- * (`Kind.Checking`, ids = declaration order, each a BARE `bigint` — no
- * brand), the `fromId` weld, an `id` field descriptor carrying the CLOSED
- * LINKAGE (the roster — pure structure, no declared domain: the laws type
- * the columns, and `schema()` names the id's generator class `"Kind.id"`)
- * for other relations' field blocks (`kind: Kind.id`), payload readback
- * (`Kind.axioms`), and the declared payload column descriptors
- * (`Kind.columns` — the runtime twin of the `Cols` type parameter, which
- * the face layer's structural wall reads). Bare tier: `closed("Kind", ["Checking",
+ * tiers, one function. Bare tier: `closed("Kind", ["Checking",
  * "Savings"])`. Payload tier: `closed("Sev", { pages: bool }, { Critical:
  * { pages: true }, ... })` — one call, three arguments (the curried tier-2
  * spelling is DELETED — canonical utterance): the axioms record IS the
  * handle declaration, every handle carrying every column exactly once
- * (type-enforced). No fact type and no insert surface exist — closed
- * relations are unwritable by construction: the value simply lacks the
- * writable relation shape. Both tiers mint `match()` — exhaustive dispatch
- * over the handle union (arms typed by the mapped type, so a missing or
- * extra arm is a compile error; the payload tier's arm receives the typed
- * axiom row). The payload tier additionally mints `where()` — the
- * ψ-selection surface (`Kind.where({ mastered: true })` as a face source),
- * resolved through the ONE selection machine
- * (`relation.ts::resolveSelection`); the bare tier has no payload columns to
- * select on, so `.where` is absent there, at the type AND on the value.
+ * (type-enforced). At the host surface a handle is its NAME — a string
+ * literal of the roster's union (the drizzle law: translation, not
+ * abstraction; dispatch over a vocabulary is native `switch` narrowing, so
+ * no match operator is minted and no handle constants exist — the literal
+ * `"Checking"` is the ONE spelling). Handles are pure DATA, not properties
+ * of the value, so NO handle name is reserved: a vocabulary may legally
+ * contain handles named `match`, `where`, or `id` — the axioms record and
+ * the roster are their own namespaces. The value's whole surface: `name`;
+ * `id` — the field descriptor carrying the CLOSED LINKAGE (the roster —
+ * pure structure, no declared domain: the laws type the columns, and
+ * `schema()` names the id's generator class `"Kind.id"`) for other
+ * relations' field blocks (`kind: Kind.id`); `data` (the lowering
+ * carrier); `axioms` (payload readback, `Kind.axioms`); `columns` (the
+ * runtime twin of the `Cols` type parameter, which the face layer's
+ * structural wall reads); and — exactly when payload columns exist —
+ * `where()`, the ψ-selection surface (`Kind.where({ mastered: true })` as a
+ * face source), resolved through the ONE selection machine
+ * (`relation.ts::resolveSelection`); the bare tier has no payload columns
+ * to select on, so `.where` is absent there, at the type AND on the value.
+ * No fact type and no insert surface exist — closed relations are
+ * unwritable by construction: the value simply lacks the writable relation
+ * shape.
  */
-import type { OneOf } from "#face.ts";
 import { type AnyField, type ClosedIdField, type Infer } from "#fields.ts";
-import { type SelectionBinding } from "#relation.ts";
+import { type SelectionBinding, type SelectionInput } from "#relation.ts";
 import type { LiteralSpec } from "#spec.ts";
 /**
  * A payload column of a closed relation: any field descriptor except a
@@ -93,12 +95,14 @@ interface ClosedCore<Name extends string, Handles extends string, Cols extends R
     readonly name: Name;
     /**
      * The closed reference descriptor: `kind: Kind.id` in another relation's
-     * field block is the reference through which bare handle ids become
-     * legal in that relation's selections. Pure structure plus the roster —
-     * the referencing field's domain is law-born: `schema()` computes it
-     * from the declared containment (`"Kind.id"`, the generator class).
+     * field block is the reference through which handle literals become
+     * legal in that relation's selections. Pure structure plus the PRECISE
+     * roster (`ClosedIdField<Handles>` — the handle union is the field's
+     * value type under `Infer`); the referencing field's domain is law-born:
+     * `schema()` computes it from the declared containment (`"Kind.id"`, the
+     * generator class).
      */
-    readonly id: ClosedIdField;
+    readonly id: ClosedIdField<Handles>;
     readonly data: ClosedData;
     /** Payload readback: handle to its declared column values, bare and structural. */
     readonly axioms: Axioms<Handles, Cols>;
@@ -111,19 +115,17 @@ interface ClosedCore<Name extends string, Handles extends string, Cols extends R
      * descriptors in declaration order for the lowering).
      */
     readonly columns: Cols;
-    /** The weld: declaration-order id back to its handle, or undefined beyond the roster. */
-    fromId(id: bigint): Handles | undefined;
 }
 /**
- * The `where()` argument of a closed relation: per PAYLOAD column, a bare
- * structural literal of that column's value type or an `oneOf(a, b, ...)`
- * literal set — the ordinary `where()`'s vocabulary exactly. The synthetic
- * `id` is deliberately absent: an id selection is spelled only as handle
- * literals on the REFERENCING side (the canonical-utterance law).
+ * The `where()` argument of a closed relation: EXACTLY the relation
+ * surface's {@link SelectionInput}, over the declared payload columns — the
+ * ONE selection vocabulary, so a spelling change there (H3's membership
+ * arrays) flows through with no local change here. The synthetic `id` is
+ * deliberately unspellable ({@link PayloadColumns} refuses an `id` column):
+ * an id selection is spelled only as handle literals on the REFERENCING
+ * side (the canonical-utterance law).
  */
-type ClosedSelectionInput<Cols extends Record<string, PayloadField>> = {
-    readonly [C in keyof Cols]?: Infer<Cols[C]> | OneOf<Infer<Cols[C]>>;
-};
+type ClosedSelectionInput<Cols extends Record<string, PayloadField>> = SelectionInput<Cols>;
 /**
  * A closed relation with a ψ selection applied — what `on()` consumes as a
  * σ-carrying closed source (`on(Kind.where({ mastered: true }), "id")`).
@@ -152,42 +154,17 @@ interface ClosedSelectable<Name extends string, Handles extends string, Cols ext
     where(selection: ClosedSelectionInput<Cols>): SelectedClosed<Name, Handles, Cols>;
 }
 /**
- * Exhaustive dispatch over a BARE closed vocabulary: one arm per handle,
- * no literal types and no brands — the handle-name union on the value's
- * type IS the exhaustiveness proof (a missing arm is a missing-property
- * compile error; an extra arm an excess-property compile error). The bare
- * tier declares no payload, so an arm takes nothing. The arms record types
- * any `bigint` in — the runtime roster refuses an out-of-vocabulary id
- * with a throw, never a misdispatch.
- */
-interface ClosedMatchBare<Handles extends string> {
-    match<T>(id: bigint, arms: {
-        readonly [H in Handles]: () => T;
-    }): T;
-}
-/**
- * Exhaustive dispatch over a PAYLOAD-tier closed vocabulary: the same
- * mapped-type exhaustiveness as the bare tier, and each arm receives its
- * handle's typed axiom row (the declared columns, bare and structural —
- * the frozen readback row from `axioms`).
- */
-interface ClosedMatchPayload<Handles extends string, Cols extends Record<string, PayloadField>> {
-    match<T>(id: bigint, arms: {
-        readonly [H in Handles]: (row: AxiomRow<Cols>) => T;
-    }): T;
-}
-/**
- * A closed relation value: the core surface plus one BARE constant per
- * handle (`Kind.Checking: bigint`, ids = declaration order — the value is
- * structural; the roster judges out-of-vocabulary ids at construction and
- * the engine at commit), plus `match()` on BOTH tiers (bare arms take
- * nothing; payload arms receive the typed axiom row), plus — exactly when
- * payload columns exist — `where()` (the bare tier has nothing to select
- * on, so the method is ABSENT there, not merely uncallable).
+ * A closed relation value: the core surface plus — exactly when payload
+ * columns exist — `where()` (the bare tier has nothing to select on, so
+ * the method is ABSENT there, not merely uncallable). NOTHING else:
+ * handles are data on the roster, never properties of the value (the
+ * handle constants, the match operator, and the id-to-handle weld died
+ * with the bigint era — dispatch is native `switch` narrowing over the
+ * handle union).
  */
-type Closed<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> = ClosedCore<Name, Handles, Cols> & {
-    readonly [H in Handles]: bigint;
-} & ([keyof Cols] extends [never] ? ClosedMatchBare<Handles> : ClosedSelectable<Name, Handles, Cols> & ClosedMatchPayload<Handles, Cols>);
+type Closed<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> = [
+    keyof Cols
+] extends [never] ? ClosedCore<Name, Handles, Cols> : ClosedCore<Name, Handles, Cols> & ClosedSelectable<Name, Handles, Cols>;
 /** Any closed relation value, whatever its roster and columns. */
 interface AnyClosed {
     readonly name: string;
@@ -211,6 +188,6 @@ declare function closed<const Name extends string, const Handles extends readonl
  * {@link Axioms}).
  */
 declare function closed<const Name extends string, const Cols extends PayloadColumns, Handles extends string>(name: Name, columns: Cols, axioms: Axioms<Handles, Cols>): Closed<Name, Handles, Cols>;
-export type { AnyClosed, AnySelectedClosed, AxiomRow, Axioms, Closed, ClosedColumn, ClosedCore, ClosedData, ClosedRow, ClosedSelectionInput, PayloadField, SelectedClosed };
+export type { AnyClosed, AnySelectedClosed, AxiomRow, Axioms, Closed, ClosedColumn, ClosedCore, ClosedData, ClosedRow, ClosedSelectable, ClosedSelectionInput, PayloadField, SelectedClosed };
 export { closed };
 //# sourceMappingURL=closed.d.ts.map

package/dist/closed.d.ts.map

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