@bjornpagen/bumbledb 0.3.0 → 0.5.0

package/src/query/predicate.ts

@@ -29,7 +29,7 @@
 
 import * as errors from "@superbuilders/errors"
 import type { SchemaClasses } from "#law.ts"
-import type { RecData } from "#query/atom.ts"
+import type { RecData, RuleData, SelectColumn } from "#query/atom.ts"
 import type {
 	AnyRuleValue,
 	HeadOf,
@@ -45,8 +45,8 @@ import type {
 	RuleValue
 } from "#query/lower.ts"
 import { makeOutputRuleScope, makeQuery, makeRawScope } from "#query/lower.ts"
-import type { Flatten, ParamsRecord, ShapeOf } from "#query/scope.ts"
-import { inferred } from "#query/scope.ts"
+import type { ClassedField, Flatten, ParamsRecord, ShapeOf } from "#query/scope.ts"
+import { fieldJoins, inferred, renderFieldKind } from "#query/scope.ts"
 import type { Schema, SchemaRelations } from "#schema.ts"
 
 /**
@@ -112,6 +112,20 @@ interface RawRec<Name extends string> {
 	rule(build: (r: RawScope) => RuleValue<never, never>): RawRec<Name>
 }
 
+/**
+ * The classed slot one rec head column binds, through the rule's own
+ * environment: a rec head projects bound variable NAMES only (the strata
+ * roster's unwritability), so every column is a projected var and its
+ * slot is the var's first positive binding.
+ */
+function recHeadSlotOf(rule: RuleData, column: SelectColumn): ClassedField | undefined {
+	const entry = column.entry
+	if (entry.kind === "var") {
+		return rule.varFields[entry.over]
+	}
+	return undefined
+}
+
 /** Builds the runtime rec handle over shared rec data. */
 function makeRawRec<Name extends string>(state: ProgramState, name: Name, data: RecData): RawRec<Name> {
 	const rec: RawRec<Name> = {
@@ -137,6 +151,26 @@ function makeRawRec<Name extends string>(state: ProgramState, name: Name, data:
 						`rec ${name}: every rule derives the same head — rule 0 projects (${declared.join(", ")}), this rule projects (${candidate.join(", ")})`
 					)
 				}
+				// The law-class wall on the sealed head: names alone do not
+				// align value spaces. Every rule must bind each head column
+				// at a slot that JOINS rule 0's (the sealing rule — the one
+				// slot every downstream idb pairing class-checks against),
+				// under the same fieldJoins judgment every reuse site
+				// enforces; otherwise a later rule feeds (say) bare weights
+				// into a column the idb joins as Node ids.
+				built.rule.select.forEach(function verifyHeadSlot(column, position) {
+					const lead = head.select[position]
+					if (lead === undefined) {
+						return
+					}
+					const leadSlot = recHeadSlotOf(head, lead)
+					const slot = recHeadSlotOf(built.rule, column)
+					if (leadSlot !== undefined && slot !== undefined && !fieldJoins(leadSlot, slot)) {
+						throw errors.new(
+							`rec ${name}: every rule derives the same head — the head column ${lead.name} is bound at ${renderFieldKind(leadSlot)} in rule 0 but at ${renderFieldKind(slot)} in this rule (a head column joins only class-equal slots; bare pairs only with bare)`
+						)
+					}
+				})
 			}
 			data.rules.push(built.rule)
 			return makeRawRec<Name>(state, name, data)
@@ -147,7 +181,8 @@ function makeRawRec<Name extends string>(state: ProgramState, name: Name, data:
 }
 
 /**
- * The rec handles' trusted admission seam (the `refsComplete` pattern):
+ * The rec handles' trusted admission seam (the pattern's home is
+ * `isTypedScope` in query/lower.ts):
  * the checkable fact — the handle owns exactly the rec data it names — is
  * verified before the raw handle is admitted at its typed face.
  */

package/src/query/run.ts

@@ -8,20 +8,22 @@
  * values — the marshal boundary is pure both ways: the engine computed
  * the answer under the prepared head, so a decoded row that carries every
  * select column IS a row (the trusted read seam), and nothing is asserted
- * on any value. Answers are SETS — no order or limit exists anywhere;
- * hosts sort. The `Prepared` VALUE itself (no lifecycle, GC-reclaimed
- * plan) lives in `#db.ts`.
+ * on any value. A CLOSED answer column decodes id → handle NAME through
+ * the marshal's one bijection (`handleOf` — the same read half every fact
+ * decode rides; the column's roster rides `SelectColumn.closed`), so query
+ * rows speak the vocabulary exactly as scans and gets do. Answers are
+ * SETS — no order or limit exists anywhere; hosts sort. The `Prepared`
+ * VALUE itself (no lifecycle, GC-reclaimed plan) lives in `#db.ts`.
  */
 
 import * as errors from "@superbuilders/errors"
+import { handleOf } from "#marshal.ts"
 import type { FactValue, QueryParam, TaggedValue } from "#native.ts"
 import type { SelectColumn } from "#query/atom.ts"
+import { ALLEN_ALL_BITS } from "#query/atom.ts"
 import { taggedCmpLiteral } from "#query/lower.ts"
 import type { ParamEntry } from "#query/scope.ts"
 
-/** The 13-bit Allen mask ceiling (`bumbledb/crates/bumbledb/src/allen.rs`: bits above the low 13 are unrepresentable). */
-const ALLEN_ALL_BITS = (1 << 13) - 1
-
 /** Tags one supplied mask-param value. */
 function wireMask(name: string, value: unknown): TaggedValue {
 	if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > ALLEN_ALL_BITS) {
@@ -45,10 +47,23 @@ function wireValue(entry: ParamEntry, context: string, value: unknown): TaggedVa
  * in registry order (= the lowering's dense `ParamId`s). A missing entry
  * is a typed error naming the param; values tag by the anchoring use's
  * structural type; a set param takes a readonly array (the empty set is
- * legal and matches nothing — the engine's rule).
+ * legal and matches nothing — the engine's rule). A MEMBERSHIP-ARRAY
+ * entry (`members` present — a literal set folded into the program) is
+ * supplied by the SDK itself: each handle name rides the one
+ * roster-verification point (`taggedHandleId`, through `wireValue`) and
+ * crosses as the same `{ kind: "set", values }` a bound `r.inSet` param
+ * crosses as — the host's params object is never consulted for it.
  */
 function wireParams(entries: readonly ParamEntry[], supplied: Readonly<Record<string, unknown>>): QueryParam[] {
 	return entries.map(function wireOne(entry): QueryParam {
+		if (entry.members !== undefined) {
+			return {
+				kind: "set",
+				values: entry.members.map(function wireMember(member, index) {
+					return wireValue(entry, `membership array ${entry.name}[${index}]`, member)
+				})
+			}
+		}
 		const value = supplied[entry.name]
 		if (value === undefined) {
 			throw errors.new(`execute params object is missing param ${entry.name}`)
@@ -90,7 +105,9 @@ function isAnswerRow<Row>(
 /**
  * Decodes positional answer rows (column order = the program's head order
  * = the select's written order) to named, frozen row objects of bare
- * structural values.
+ * structural values. A closed column lifts its row id back to the handle
+ * NAME through the marshal's bijection — an out-of-roster id is the same
+ * pointed throw a fact decode gives, never a silent fallback.
  */
 function decodeAnswers<Row>(select: readonly SelectColumn[], rows: FactValue[][]): Row[] {
 	return rows.map(function decodeRow(row) {
@@ -103,7 +120,8 @@ function decodeAnswers<Row>(select: readonly SelectColumn[], rows: FactValue[][]
 			if (cell === undefined) {
 				throw errors.new(`query answer cell ${ordinal} (${column.name}) is absent`)
 			}
-			decoded[column.name] = cell
+			decoded[column.name] =
+				column.closed === undefined ? cell : handleOf(`query answer column ${column.name}`, column.closed, cell)
 		})
 		Object.freeze(decoded)
 		if (!isAnswerRow<Row>(select, decoded)) {

package/src/query/scope.ts

@@ -19,8 +19,8 @@
  * inference ride.
  */
 
-import * as errors from "@superbuilders/errors"
 import type { AnyField, Infer } from "#fields.ts"
+import { rosterOf } from "#fields.ts"
 
 /**
  * The runtime discriminant of query term values. Host literals (bigints,
@@ -110,57 +110,6 @@ 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 }
@@ -228,25 +177,38 @@ type WidthOf<F extends AnyField> = F extends { readonly width: infer W } ? W : u
 /** Reads an interval descriptor's element kind; `undefined` on scalar kinds. */
 type ElementOf<F extends AnyField> = F extends { readonly element: infer E } ? E : undefined
 
+/** Reads a closed reference's handle union; `undefined` on every non-closed kind (the roster IS descriptor structure). */
+type RosterOf<F extends AnyField> = F extends {
+	readonly closed: { readonly handles: readonly (infer H extends string)[] }
+}
+	? H
+	: undefined
+
 /**
  * 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.
+ * agrees (kind, width label, interval element, and the closed ROSTER — a
+ * closed reference pairs only with the same vocabulary, never with a bare
+ * u64: the roster keys every closed judgment downstream, so a join across
+ * it would decode/order/translate incoherently by binding order) 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 beyond the roster exists to compare.
  */
 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 [
+	ElementOf<A["field"]>,
+	RosterOf<A["field"]>
+] extends [B["field"]["kind"], B["class"], WidthOf<B["field"]>, ElementOf<B["field"]>, RosterOf<B["field"]>]
+	? [B["field"]["kind"], B["class"], WidthOf<B["field"]>, ElementOf<B["field"]>, RosterOf<B["field"]>] extends [
 			A["field"]["kind"],
 			A["class"],
 			WidthOf<A["field"]>,
-			ElementOf<A["field"]>
+			ElementOf<A["field"]>,
+			RosterOf<A["field"]>
 		]
 		? true
 		: false
@@ -255,7 +217,8 @@ type JoinOk<A extends ClassedField, B extends ClassedField> = [
 /**
  * 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
+ * judged on the honest runtime values (the descriptor, the roster by VALUE
+ * IDENTITY — vocabulary identity is value identity — 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.
@@ -265,17 +228,31 @@ function fieldJoins(a: ClassedField, b: ClassedField): boolean {
 	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
+	const rosterA = rosterOf(a.field)
+	const rosterB = rosterOf(b.field)
+	return (
+		a.field.kind === b.field.kind &&
+		a.class === b.class &&
+		widthA === widthB &&
+		elementA === elementB &&
+		rosterA === rosterB
+	)
 }
 
 /**
  * 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`).
+ * kind in the schema grammar's spelling (a closed reference names its
+ * vocabulary: the roster is part of the structure being compared) plus the
+ * slot's law-computed class (`u64 in class Holder.id`; a lawless slot
+ * renders `bare`).
  */
 function renderFieldKind(slot: ClassedField): string {
 	const field = slot.field
 	let base: string = field.kind
+	const roster = rosterOf(field)
+	if (roster !== undefined) {
+		base = `u64 referencing ${roster.name}`
+	}
 	if (field.kind === "bytes") {
 		base = `bytes<${field.width}>`
 	}
@@ -287,7 +264,10 @@ function renderFieldKind(slot: ClassedField): string {
 
 /**
  * What a PARAM anchored at field `F` accepts at execution: the field's
- * bare value type, exactly. At an interval field the engine resolves the
+ * bare value type, exactly — at a CLOSED-reference field that is the
+ * handle-name union (`"DirectPass" | "Failed"`), translated name → row id
+ * at execute through the one roster-verification point
+ * (`taggedHandleId`). At an interval field the engine resolves the
  * bivalent anchor to the INTERVAL reading (value equality) — the point
  * reading of a param is spelled `pointIn(r.param(...), w)`, whose sibling
  * anchors it element-typed.
@@ -304,13 +284,17 @@ type InferredOf<T> = T extends { readonly [inferred]?: infer S } ? Exclude<S, un
  * positions) — the op keeps literal tagging op-aware at `pointIn`
  * (the bug-hunt fix, preserved). `anchor` is `undefined` only on a query
  * built but not yet anchored by any rule; lowering and the wire both refuse
- * that state typed.
+ * that state typed. `members` is present exactly on a MEMBERSHIP-ARRAY
+ * entry (a literal set at a closed field, folded into the program): the
+ * SDK itself translates and supplies the set at every execute — the entry
+ * is never read from, and never demanded of, the host's params object.
  */
 interface ParamEntry {
 	readonly name: string
 	readonly shape: "value" | "set" | "mask"
 	readonly anchor: AnyField | "measure" | undefined
 	readonly op: "binding" | "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "pointIn" | "allen"
+	readonly members: readonly string[] | undefined
 }
 
 export type {
@@ -329,8 +313,7 @@ export type {
 	SetParam,
 	ShapeOf,
 	UnionToIntersection,
-	Var,
-	VarsRecord
+	Var
 }
 export {
 	fieldJoins,
@@ -341,7 +324,6 @@ export {
 	makeParam,
 	makeSetParam,
 	makeVar,
-	makeVars,
 	renderFieldKind,
 	term
 }

package/src/relation.ts

@@ -2,51 +2,60 @@
  * `relation()` — the ordinary-relation half of the theory's signature. A
  * relation value is a frozen plain object carrying its name, its ordered
  * field descriptors (declaration order = ordinal ids, the macro's law),
- * typed field references (`R.fields.holder`), and — since selections are
- * the relation's own vocabulary — `where()`, which resolves a selection
- * into lowered bindings eagerly (handles verified against their roster at
- * construction). `Fact<>`/`InsertFact<>` are the inferred row object
- * types at BARE structural value types (no brands): fresh fields are
- * optional on insert input (omit-to-mint) and present on read
+ * and — since selections are the relation's own vocabulary — `where()`,
+ * which resolves a selection into lowered bindings eagerly (handles
+ * verified against their roster at construction). Fields are addressed by
+ * NAME everywhere — statements (`on(R, "holder")`), selections, and match
+ * records all spell the field's own name, checked by type
+ * (`FaceFields`/`MatchShape`). `Fact<>`/`InsertFact<>` are the inferred
+ * row object types at BARE structural value types (no brands): fresh
+ * fields are optional on insert input (omit-to-mint) and present on read
  * (resupply-to-preserve-identity), typed exactly.
  */
 
 import * as errors from "@superbuilders/errors"
-import type { OneOf } from "#face.ts"
 import { type AnyField, assertDeclarationOrderKey, type Infer, literalOf } from "#fields.ts"
-import type { LiteralSetSpec, LiteralSpec } from "#spec.ts"
+import { type LiteralSetSpec, type LiteralSpec, renderLiteral } from "#spec.ts"
 
 /** Flattens an intersection into one displayed object type (hover legibility). */
 type Flatten<T> = { [K in keyof T]: T[K] }
 
 /**
- * The one trusted seam of `relation()`: the reference record is built by
- * iterating the declared fields, and this guard verifies the checkable
- * facts — one reference per declared field, each carrying its own name —
- * before the record is admitted as the typed {@link FieldRefs} (the
- * macro-emission analog).
+ * Resolves one selection entry to its lowered literal set: a plain ARRAY
+ * (detected by `Array.isArray` — no field's value type is an array;
+ * `Uint8Array` is not one) becomes a disjunctive set, anything else the
+ * bare literal. The degenerate sets are construction errors, each
+ * self-locating (`context` names the relation and field) — the empty set
+ * selects nothing, the one-element set is the bare literal respelled, and
+ * a DUPLICATE literal (judged on the canonical rendering — the engine's
+ * own duplicate test, reached here first so its index-speak twin at
+ * `Db.create` stays unreachable from this surface) is the same respelling
+ * in disguise (the canonical-utterance law; the old set combinator's
+ * signature made the length degenerates unwritable, and the refusals here
+ * are that law's runtime seat). The lowered set — `{ kind: "many",
+ * literals }` — is byte-identical to what the combinator produced, so no
+ * fingerprint moves.
  */
-function refsComplete<RName extends string, Fields extends FieldsShape>(
-	refs: Record<string, unknown>,
-	fields: Fields
-): refs is FieldRefs<RName, Fields> {
-	return Object.keys(fields).every(function hasRef(fieldName) {
-		const ref = refs[fieldName]
-		return typeof ref === "object" && ref !== null && "field" in ref && ref.field === fieldName
-	})
-}
-
-/**
- * Resolves one selection entry to its lowered literal set: an `oneOf`
- * value (detected by its `literals` tuple — no field value is ever an
- * object carrying `literals`) becomes a disjunctive set (≥ 2 by the
- * `oneOf` signature — the one-element set is unwritable); anything else is
- * the bare literal.
- */
-function resolveEntry(field: AnyField, entry: unknown): LiteralSetSpec {
-	if (typeof entry === "object" && entry !== null && "literals" in entry && Array.isArray(entry.literals)) {
-		const literals: LiteralSpec[] = entry.literals.map(function lowerSetLiteral(literal: unknown) {
-			return Object.freeze(literalOf(field, literal))
+function resolveEntry(context: string, field: AnyField, entry: unknown): LiteralSetSpec {
+	if (Array.isArray(entry)) {
+		if (entry.length < 2) {
+			throw errors.new(
+				entry.length === 0
+					? `${context}: an empty literal set selects nothing — write the selection you mean`
+					: `${context}: a one-element literal set is the bare literal respelled — write the literal (the canonical-utterance law: one meaning, one spelling)`
+			)
+		}
+		const seen = new Set<string>()
+		const literals: LiteralSpec[] = entry.map(function lowerSetLiteral(literal: unknown) {
+			const lowered = Object.freeze(literalOf(field, literal))
+			const rendered = renderLiteral(lowered)
+			if (seen.has(rendered)) {
+				throw errors.new(
+					`${context}: the literal set spells ${rendered} twice — write it once (the canonical-utterance law: one meaning, one spelling)`
+				)
+			}
+			seen.add(rendered)
+			return lowered
 		})
 		return Object.freeze({ kind: "many", literals: Object.freeze(literals) })
 	}
@@ -78,7 +87,9 @@ function resolveSelection(
 		if (declared === undefined) {
 			throw errors.new(`relation ${name} has no field ${fieldName}`)
 		}
-		bindings.push(Object.freeze({ field: fieldName, set: resolveEntry(declared.field, entry) }))
+		bindings.push(
+			Object.freeze({ field: fieldName, set: resolveEntry(`relation ${name}.${fieldName}`, declared.field, entry) })
+		)
 	}
 	if (bindings.length === 0) {
 		throw errors.new(
@@ -91,22 +102,6 @@ function resolveSelection(
 /** The field block of a relation: field name to field descriptor. */
 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 is read off the
- * relation's schema type structurally.
- */
-interface FieldRef<Rel extends string, Name extends string> {
-	readonly relation: Rel
-	readonly field: Name
-}
-
-/** The typed field-reference record of a relation. */
-type FieldRefs<RName extends string, Fields extends FieldsShape> = {
-	readonly [K in keyof Fields & string]: FieldRef<RName, K>
-}
-
 /** One declared field: name plus its descriptor, in declaration order. */
 interface RelationField {
 	readonly name: string
@@ -131,13 +126,15 @@ interface SelectionBinding {
 
 /**
  * The `where()` argument: per field, a bare structural literal of that
- * field's value type (a closed handle constant IS such a literal — a
- * bigint verified against the roster at construction), an `oneOf(a, b,
- * ...)` literal set, or a `span(start, end)` interval literal.
- * Equality-only by construction: no operator parameter exists anywhere.
+ * field's value type (a closed reference's literal IS its handle name —
+ * `"Savings"`, verified against the roster at construction), a plain
+ * ARRAY of such literals read disjunctively — `kind: ["Checking",
+ * "Savings"]` — or a `span(start, end)` interval literal. Membership is
+ * an array, never an operator (the drizzle law); equality-only by
+ * construction: no operator parameter exists anywhere.
  */
 type SelectionInput<Fields extends FieldsShape> = {
-	readonly [K in keyof Fields]?: Infer<Fields[K]> | OneOf<Infer<Fields[K]>>
+	readonly [K in keyof Fields]?: Infer<Fields[K]> | readonly Infer<Fields[K]>[]
 }
 
 /** A relation with a selection applied — what `on()` consumes as a σ-carrying source. */
@@ -150,7 +147,6 @@ interface Selected<Name extends string, Fields extends FieldsShape> {
 interface Relation<Name extends string, Fields extends FieldsShape> {
 	readonly name: Name
 	readonly data: RelationData
-	readonly fields: FieldRefs<Name, Fields>
 	where(selection: SelectionInput<Fields>): Selected<Name, Fields>
 }
 
@@ -208,14 +204,6 @@ function relation<const Name extends string, Fields extends FieldsShape>(
 		ordered.push(Object.freeze({ name: fieldName, field }))
 	}
 	const data: RelationData = Object.freeze({ name, fields: Object.freeze(ordered) })
-	const refs: Record<string, unknown> = {}
-	for (const declared of ordered) {
-		refs[declared.name] = Object.freeze({ relation: name, field: declared.name })
-	}
-	Object.freeze(refs)
-	if (!refsComplete<Name, Fields>(refs, fields)) {
-		throw errors.new(`relation ${name}: field-reference construction incomplete`)
-	}
 	const holder: { value: Relation<Name, Fields> | undefined } = { value: undefined }
 	function where(selection: SelectionInput<Fields>): Selected<Name, Fields> {
 		const owner = holder.value
@@ -227,7 +215,7 @@ function relation<const Name extends string, Fields extends FieldsShape>(
 			selection: resolveSelection(name, ordered, Object.entries(selection))
 		})
 	}
-	const value: Relation<Name, Fields> = Object.freeze({ name, data, fields: refs, where })
+	const value: Relation<Name, Fields> = Object.freeze({ name, data, where })
 	holder.value = value
 	return value
 }
@@ -236,8 +224,6 @@ export type {
 	AnyRelation,
 	AnySelected,
 	Fact,
-	FieldRef,
-	FieldRefs,
 	FieldsShape,
 	FreshKeys,
 	InsertFact,

package/src/schema.ts

@@ -11,8 +11,9 @@
 
 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 { type AnyField, assertDeclarationOrderKey, type ClosedRoster } from "#fields.ts"
+import { assertDeclarationOrderKey, 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"
@@ -34,7 +35,7 @@ function collectImplied(name: string, relations: SchemaRelations): Set<string> {
 				`schema ${name}: record key ${recordKey} holds relation ${member.name} — the key must equal the relation's declared name`
 			)
 		}
-		if ("handles" in member.data) {
+		if (isClosedMember(member)) {
 			implied.add(`${member.name}(id) -> ${member.name}`)
 			continue
 		}
@@ -75,33 +76,6 @@ function verifyMembership(name: string, relations: SchemaRelations, statement: S
 	}
 }
 
-/** Finds a face's field descriptor by name, across both relation kinds. */
-function faceField(face: FaceData, fieldName: string): AnyField | undefined {
-	const data = face.owner.data
-	if ("handles" in data) {
-		const column = data.columns.find(function byName(candidate) {
-			return candidate.name === fieldName
-		})
-		return column?.field
-	}
-	const declared = data.fields.find(function byName(candidate) {
-		return candidate.name === fieldName
-	})
-	return declared?.field
-}
-
-/**
- * The roster a field resolves handles through: present exactly on a closed
- * reference descriptor (the structural `closed` property — S1's
- * `ClosedIdField`), absent on every other field kind.
- */
-function rosterOf(field: AnyField | undefined): ClosedRoster | undefined {
-	if (field !== undefined && "closed" in field) {
-		return field.closed
-	}
-	return undefined
-}
-
 /** Flattens one binding's literal set into its literals. */
 function bindingLiterals(set: LiteralSetSpec): readonly LiteralSpec[] {
 	if (set.kind === "one") {
@@ -122,7 +96,7 @@ function verifyBindingHandles(
 	binding: { readonly field: string; readonly set: LiteralSetSpec },
 	rendered: string
 ): void {
-	const roster = rosterOf(faceField(face, binding.field))
+	const roster = rosterOf(sealedFieldOf(face.owner, binding.field))
 	for (const literal of bindingLiterals(binding.set)) {
 		if (literal.kind !== "handle") {
 			continue
@@ -177,7 +151,7 @@ function closedTargetOf(statements: readonly Statement[], owner: string, field:
 				source.projection[0] === field &&
 				target.projection.length === 1 &&
 				target.projection[0] === "id" &&
-				"handles" in target.owner.data
+				isClosedMember(target.owner)
 			) {
 				return target.owner.name
 			}
@@ -227,11 +201,11 @@ function verifyClosedReferenceBinding(
 	if (!spellsHandle) {
 		return
 	}
-	const roster = rosterOf(faceField(face, binding.field))
+	const roster = rosterOf(sealedFieldOf(face.owner, binding.field))
 	if (roster === undefined) {
 		return
 	}
-	if ("handles" in face.owner.data && binding.field === "id") {
+	if (isClosedMember(face.owner) && binding.field === "id") {
 		return
 	}
 	const resolved = closedTargetOf(statements, face.owner.name, binding.field)

package/src/spec.ts

@@ -62,8 +62,9 @@ type LiteralSpec =
 
 /**
  * One σ binding's right side: a single literal or a literal set (read
- * disjunctively). The SDK's selection constructors make the degenerate sets
- * unwritable (`oneOf` demands two leading literals), so a lowered `many`
+ * disjunctively). The SDK's selection resolver refuses the degenerate sets
+ * (a membership array needs two members — the empty set selects nothing,
+ * the one-element set is the bare literal respelled), so a lowered `many`
  * always carries ≥ 2 literals.
  */
 type LiteralSetSpec =