@bjornpagen/bumbledb 0.4.0 → 0.5.0

package/src/query/lower.ts

@@ -26,8 +26,9 @@
  */
 
 import * as errors from "@superbuilders/errors"
+import { sealedFieldsOf } from "#closed.ts"
 import type { AnyField, ClosedRoster } from "#fields.ts"
-import { assertDeclarationOrderKey } from "#fields.ts"
+import { assertDeclarationOrderKey, isIntervalValue, literalShapeError, rosterOf } from "#fields.ts"
 import type { ClassRecordOf, SchemaClasses } from "#law.ts"
 import type {
 	AtomIr,
@@ -68,7 +69,7 @@ import type {
 	SelectEntryData,
 	TreeData
 } from "#query/atom.ts"
-import { allen, and, covers, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts"
+import { allen, and, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts"
 import type {
 	ClassedField,
 	EnvShape,
@@ -88,13 +89,12 @@ import {
 	makeParam,
 	makeSetParam,
 	makeVar,
-	makeVars,
 	renderFieldKind,
 	term
 } from "#query/scope.ts"
 import type { CheckNameSelect, CheckSelect, RowOfNameSelect, RowOfSelect, SelectEntry } from "#query/select.ts"
 import { argMax, argMin, count, countDistinct, max, min, pack, sum } from "#query/select.ts"
-import type { FieldsShape, RelationField } from "#relation.ts"
+import type { FieldsShape } from "#relation.ts"
 import type { AnySchema, Schema, SchemaRelations } from "#schema.ts"
 
 /**
@@ -198,8 +198,6 @@ type CheckIdbVars<Env extends EnvShape, V, Head extends HeadShape = undefined> =
 interface TermOps {
 	/** Declares/names one variable: typed by the field it first binds; reuse joins. */
 	readonly var: typeof makeVar
-	/** Mints several variables at once — `const { service, w } = r.vars("service", "w")`: each name typed exactly; duplicates refuse. */
-	readonly vars: typeof makeVars
 	/** Names one scalar parameter: typed by its use; the key of the execute params object. */
 	readonly param: typeof makeParam
 	/** Names one ∈-set parameter (the IR's `ParamSet`): bound to a readonly array at execution. */
@@ -215,7 +213,6 @@ interface TermOps {
 	readonly gt: typeof gt
 	readonly ge: typeof ge
 	readonly pointIn: typeof pointIn
-	readonly covers: typeof covers
 	readonly allen: typeof allen
 	readonly and: typeof and
 	readonly or: typeof or
@@ -431,7 +428,6 @@ interface QueryStart<Rels extends SchemaRelations, Classes extends SchemaClasses
 /** The frozen constructor vocabulary every rule builder spreads. */
 const termOps: TermOps = Object.freeze({
 	var: makeVar,
-	vars: makeVars,
 	param: makeParam,
 	inSet: makeSetParam,
 	maskParam: makeMaskParam,
@@ -443,7 +439,6 @@ const termOps: TermOps = Object.freeze({
 	gt,
 	ge,
 	pointIn,
-	covers,
 	allen,
 	and,
 	or,
@@ -479,22 +474,6 @@ interface ResolvedBindings {
 	readonly uses: readonly ParamUse[]
 }
 
-/**
- * The ordered matchable fields of an atom owner — the runtime twin of the
- * type tier's `MatchFields`: a relation's declared fields; a closed
- * relation's SEALED shape, the synthetic `id` (the value's own
- * roster-carrying descriptor, by identity) at ordinal 0 and the declared
- * payload columns at declared index + 1 (the sealed shift, mirroring
- * `spec.rs`'s resolver — a `ClosedColumn` is structurally a
- * {@link RelationField}). The lowering golden pins this mapping.
- */
-function matchFieldsOf(owner: MatchOwner): readonly RelationField[] {
-	if ("axioms" in owner) {
-		return [Object.freeze({ name: "id", field: owner.id }), ...owner.data.columns]
-	}
-	return owner.data.fields
-}
-
 /**
  * Judges one membership ARRAY at a binding position — legal exactly at a
  * CLOSED-reference field (the owner ruling: ordinary u64/str membership is
@@ -515,7 +494,8 @@ function membershipSet(
 	field: AnyField,
 	value: readonly unknown[]
 ): { readonly name: string; readonly members: readonly string[] } {
-	if (!("closed" in field)) {
+	const roster = rosterOf(field)
+	if (roster === undefined) {
 		throw errors.new(
 			`${context}: a membership array is the closed-reference spelling — ordinary field membership is a bound ∈-set param (r.inSet)`
 		)
@@ -531,7 +511,7 @@ function membershipSet(
 	const seen = new Set<string>()
 	const members = value.map(function memberName(member) {
 		if (typeof member !== "string") {
-			throw literalShapeError(context, `a ${field.closed.name} handle name (string)`, member)
+			throw literalShapeError(context, `a ${roster.name} handle name (string)`, member)
 		}
 		if (seen.has(member)) {
 			throw errors.new(
@@ -542,7 +522,7 @@ function membershipSet(
 		return member
 	})
 	const key = [...members].sort()
-	return { name: `∈ ${field.closed.name} ${JSON.stringify(key)}`, members: Object.freeze(members) }
+	return { name: `∈ ${roster.name} ${JSON.stringify(key)}`, members: Object.freeze(members) }
 }
 
 /**
@@ -564,7 +544,7 @@ function resolveBindings(
 	const vars: Array<{ readonly name: string; readonly slot: ClassedField }> = []
 	const uses: ParamUse[] = []
 	const relationClasses = classes[relation.name]
-	const ordered = matchFieldsOf(relation)
+	const ordered = sealedFieldsOf(relation)
 	for (const [fieldName, value] of Object.entries(bindings)) {
 		if (value === undefined) {
 			continue
@@ -922,7 +902,7 @@ function closedOrderError(context: string, position: string, vocabulary: string)
 	)
 }
 
-/** The comparison ops the orderable ban covers (order roster + point membership — every order-comparison position). */
+/** The comparison ops under the orderable ban (order roster + point membership — every order-comparison position). */
 function isOrderOp(op: CmpKind | "binding"): op is "lt" | "le" | "gt" | "ge" | "pointIn" {
 	return op === "lt" || op === "le" || op === "gt" || op === "ge" || op === "pointIn"
 }
@@ -960,8 +940,9 @@ function validateCond(context: string, varFields: Readonly<Record<string, Classe
 		for (const side of [cond.lhs, cond.rhs]) {
 			if (side.kind === "var") {
 				const slot = assertBound(context, varFields, side.name)
-				if (isOrderOp(cond.op) && "closed" in slot.field) {
-					throw closedOrderError(context, `the ${cond.op} side ${side.name}`, slot.field.closed.name)
+				const roster = rosterOf(slot.field)
+				if (isOrderOp(cond.op) && roster !== undefined) {
+					throw closedOrderError(context, `the ${cond.op} side ${side.name}`, roster.name)
 				}
 			}
 			if (side.kind === "measure") {
@@ -1009,12 +990,9 @@ function validateColumn(
 		case "fold": {
 			if (typeof agg.over === "string") {
 				const slot = assertBound(`${context} select ${column.name}`, varFields, agg.over)
-				if ("closed" in slot.field) {
-					throw closedOrderError(
-						`${context} select ${column.name}`,
-						`the ${agg.fold} input ${agg.over}`,
-						slot.field.closed.name
-					)
+				const roster = rosterOf(slot.field)
+				if (roster !== undefined) {
+					throw closedOrderError(`${context} select ${column.name}`, `the ${agg.fold} input ${agg.over}`, roster.name)
 				}
 				return
 			}
@@ -1024,11 +1002,12 @@ function validateColumn(
 		case "arg": {
 			assertBound(`${context} select ${column.name}`, varFields, agg.over)
 			const key = assertBound(`${context} select ${column.name}`, varFields, agg.key)
-			if ("closed" in key.field) {
+			const keyRoster = rosterOf(key.field)
+			if (keyRoster !== undefined) {
 				throw closedOrderError(
 					`${context} select ${column.name}`,
 					`the ${agg.direction} key ${agg.key}`,
-					key.field.closed.name
+					keyRoster.name
 				)
 			}
 			return
@@ -1064,11 +1043,7 @@ function selectClosedOf(
 	if (over === undefined) {
 		return undefined
 	}
-	const field = varFields[over]?.field
-	if (field !== undefined && "closed" in field) {
-		return field.closed
-	}
-	return undefined
+	return rosterOf(varFields[over]?.field)
 }
 
 /**
@@ -1267,10 +1242,12 @@ function makeRawScope(context: ChainContext): RawScope {
 }
 
 /**
- * The one trusted admission seam of the rule builders (the `relation()`
- * `refsComplete` pattern): the raw builder is one runtime shape for every
- * context, and this guard verifies the checkable fact — the builder verbs
- * exist — before the value is admitted at its TYPED face. The type-level
+ * The rule builders' trusted admission seam — THE home of the
+ * trusted-admission-seam pattern the other mint guards cite (the face,
+ * class-map, axiom-readback, rec-handle, and query-value seams): the raw
+ * builder is one runtime shape for every context, and this guard verifies
+ * the checkable fact — the builder verbs exist — before the value is
+ * admitted at its TYPED face. The type-level
  * judgments (domain-equal joins, boundness, the recursion cut) live in the
  * interfaces themselves; the runtime twin of every one of them is a
  * construction-time validation in this module.
@@ -1329,17 +1306,30 @@ function headSignature(column: SelectColumn): string {
 	return `${column.name}:${agg.op}`
 }
 
-/** The roster a param anchor carries: present exactly on a closed-reference field anchor. */
-function anchorRosterOf(anchor: AnyField | "measure" | undefined): ClosedRoster | undefined {
-	if (anchor === undefined || anchor === "measure") {
-		return undefined
+/**
+ * The classed slot one answer column's VALUES flow from, resolved through
+ * the rule's own binding environment: a projected var's first-binding slot,
+ * or an Arg-carried payload's (`argMax`/`argMin` carry `over` verbatim —
+ * the same two shapes the closed slice lifts). Counts, folds, `pack` and
+ * the measure derive numbers/intervals rather than carrying a slot's ids,
+ * so they resolve no slot (`undefined`).
+ */
+function headSlotOf(rule: RuleData, column: SelectColumn): ClassedField | undefined {
+	const entry = column.entry
+	if (entry.kind === "var") {
+		return rule.varFields[entry.over]
 	}
-	if ("closed" in anchor) {
-		return anchor.closed
+	if (entry.kind === "aggregate" && entry.agg.op === "arg") {
+		return rule.varFields[entry.agg.over]
 	}
 	return undefined
 }
 
+/** The roster a param anchor carries: present exactly on a closed-reference field anchor (rides THE one `rosterOf` reader). */
+function anchorRosterOf(anchor: AnyField | "measure" | undefined): ClosedRoster | undefined {
+	return anchor === "measure" ? undefined : rosterOf(anchor)
+}
+
 /** Renders one param anchor's closedness for the registry's coherence diagnostics. */
 function renderParamAnchor(roster: ClosedRoster | undefined): string {
 	return roster === undefined ? "a non-closed position" : `a ${roster.name} reference`
@@ -1430,13 +1420,9 @@ function paramRegistryOf(recs: readonly RecData[], rules: readonly RuleData[]):
 			if (entry === undefined) {
 				throw errors.new(`query param ${name} lost its registry entry`)
 			}
-			if (
-				entry.orderOp !== undefined &&
-				entry.anchor !== undefined &&
-				entry.anchor !== "measure" &&
-				"closed" in entry.anchor
-			) {
-				throw closedOrderError(`query param ${name}`, `its ${entry.orderOp} use's anchor`, entry.anchor.closed.name)
+			const anchorRoster = anchorRosterOf(entry.anchor)
+			if (entry.orderOp !== undefined && anchorRoster !== undefined) {
+				throw closedOrderError(`query param ${name}`, `its ${entry.orderOp} use's anchor`, anchorRoster.name)
 			}
 			return Object.freeze({ name, shape: entry.shape, anchor: entry.anchor, op: entry.op, members: entry.members })
 		})
@@ -1481,6 +1467,23 @@ function makeRawQuery(theory: AnySchema, recs: readonly RecData[], rules: readon
 					`every rule of a query derives the same head — the answer column ${lead.name} is ${renderClosedSlice(lead.closed)} in rule 0 but ${renderClosedSlice(column.closed)} in rule ${index} (one column decodes through one roster)`
 				)
 			}
+			// The law-class wall on the union head: one answer column is one
+			// value space, so the classed slot each rule binds the column at
+			// must join across rules — the SAME fieldJoins judgment every
+			// join/eq/negated-atom position enforces. The SDK holds this wall
+			// because the wire IR carries no domains: the engine cannot
+			// backstop it, and without it a union mixes (say) Holder ids and
+			// Account ids in one column the consumer reads as one id space.
+			if (lead === undefined) {
+				return
+			}
+			const leadSlot = headSlotOf(first, lead)
+			const slot = headSlotOf(rule, column)
+			if (leadSlot !== undefined && slot !== undefined && !fieldJoins(leadSlot, slot)) {
+				throw errors.new(
+					`every rule of a query derives the same head — the answer column ${lead.name} unions domain-unequal fields: bound at ${renderFieldKind(leadSlot)} in rule 0 but at ${renderFieldKind(slot)} in rule ${index} (a union column joins only class-equal slots; bare pairs only with bare)`
+				)
+			}
 		})
 	})
 	const data: QueryData = Object.freeze({
@@ -1502,7 +1505,7 @@ function makeRawQuery(theory: AnySchema, recs: readonly RecData[], rules: readon
 }
 
 /**
- * The query values' trusted admission seam (the `refsComplete` pattern):
+ * The query values' trusted admission seam (the {@link isTypedScope} pattern):
  * the checkable fact — the value was assembled over the identical theory —
  * is verified before the raw value is admitted at its typed face.
  */
@@ -1548,23 +1551,6 @@ function query<Rels extends SchemaRelations, Classes extends SchemaClasses>(
 	return start
 }
 
-/** The typed shape refusal of the literal tagger — a genuine failure, never data. */
-function literalShapeError(context: string, expected: string, value: unknown): Error {
-	return errors.new(`${context}: expected ${expected}, got ${typeof value}`)
-}
-
-/** Narrows an interval-shaped literal (a plain `{ start, end }` bigint pair). */
-function isIntervalShaped(value: unknown): value is { readonly start: bigint; readonly end: bigint } {
-	return (
-		typeof value === "object" &&
-		value !== null &&
-		"start" in value &&
-		"end" in value &&
-		typeof value.start === "bigint" &&
-		typeof value.end === "bigint"
-	)
-}
-
 /**
  * Tags one closed-reference literal: the handle NAME, verified against the
  * roster (the belt the wide fallback type cannot provide — structural
@@ -1604,7 +1590,7 @@ function taggedAtElementDomain(context: string, element: "u64" | "i64", value: u
 		}
 		return { kind: "i64", value }
 	}
-	if (isIntervalShaped(value)) {
+	if (isIntervalValue(value)) {
 		if (element === "u64") {
 			return { kind: "intervalU64", start: value.start, end: value.end }
 		}
@@ -1622,8 +1608,9 @@ function taggedAtElementDomain(context: string, element: "u64" | "i64", value: u
  * tagged u64 after a roster verification.
  */
 function taggedLiteral(context: string, field: AnyField, value: unknown): TaggedValue {
-	if ("closed" in field) {
-		return taggedHandleId(context, field.closed, value)
+	const roster = rosterOf(field)
+	if (roster !== undefined) {
+		return taggedHandleId(context, roster, value)
 	}
 	switch (field.kind) {
 		case "bool": {
@@ -1648,6 +1635,18 @@ function taggedLiteral(context: string, field: AnyField, value: unknown): Tagged
 			if (typeof value !== "string") {
 				throw literalShapeError(context, "string", value)
 			}
+			/**
+			 * The marshal's bijection law at the query seam (`marshal.ts`
+			 * cellOf): a lone surrogate would be lossily replaced with
+			 * U+FFFD at the bridge's UTF-8 crossing and silently match a
+			 * fact the typed write surface can never store — distinct JS
+			 * strings collapsing to one wire query. This is the single
+			 * seam every query string literal, string param
+			 * (`taggedCmpLiteral`), and membership member lowers through.
+			 */
+			if (!value.isWellFormed()) {
+				throw literalShapeError(context, "well-formed string", value)
+			}
 			return { kind: "string", value }
 		}
 		case "bytes": {
@@ -1665,11 +1664,11 @@ function taggedLiteral(context: string, field: AnyField, value: unknown): Tagged
  * Tags one host literal at a COMPARISON or PARAM position, where the
  * SIBLING anchors the type: a measure sibling is u64, an interval-field
  * sibling contributes its element domain (so both a point literal in
- * `covers` and a `span` literal in `allen` tag correctly), a scalar
+ * `pointIn` and a `span` literal in `allen` tag correctly), a scalar
  * sibling its own type. At `pointIn` the operand order is interval-left,
  * point-right (`ir::CmpOp::PointIn`), so an interval-shaped literal
- * beside a scalar element-typed sibling is the LEGAL lhs of
- * `covers(span(...), t)` and tags as the interval of the sibling's
+ * beside a scalar element-typed sibling is the LEGAL interval operand of
+ * `pointIn(t, span(...))` and tags as the interval of the sibling's
  * element domain; under every other operator an interval shape against a
  * scalar sibling stays refused (the engine's IllegalComparison — the
  * bug-hunt fix, preserved op-aware).
@@ -1686,14 +1685,14 @@ function taggedCmpLiteral(
 		}
 		return { kind: "u64", value }
 	}
-	if (!("closed" in sibling) && sibling.kind === "interval") {
+	if (rosterOf(sibling) === undefined && sibling.kind === "interval") {
 		return taggedAtElementDomain(context, sibling.element, value)
 	}
 	if (
 		op === "pointIn" &&
-		!("closed" in sibling) &&
+		rosterOf(sibling) === undefined &&
 		(sibling.kind === "u64" || sibling.kind === "i64") &&
-		isIntervalShaped(value)
+		isIntervalValue(value)
 	) {
 		return taggedAtElementDomain(context, sibling.kind, value)
 	}
@@ -1743,7 +1742,7 @@ function paramIdOf(ctx: LowerContext, name: string): number {
  * Lowers one EDB atom (either polarity). A CLOSED owner lowers through the
  * same edb source — its ordinal is its record-declaration slot exactly like
  * an ordinary relation's — with field ordinals over the SEALED shape: `id`
- * at 0, each payload column at its declared index + 1 (`matchFieldsOf`
+ * at 0, each payload column at its declared index + 1 (`sealedFieldsOf`
  * carries the shift; the lowering golden pins it).
  */
 function lowerAtom(ctx: LowerContext, atom: AtomData, ids: VarIds): AtomIr {
@@ -1757,7 +1756,7 @@ function lowerAtom(ctx: LowerContext, atom: AtomData, ids: VarIds): AtomIr {
 	if (relationId === undefined) {
 		throw errors.new(`query lowering: relation ${atom.relation.name} has no ordinal`)
 	}
-	const ordered = matchFieldsOf(atom.relation)
+	const ordered = sealedFieldsOf(atom.relation)
 	const bindings: Array<readonly [number, TermIr]> = atom.bindings.map(function lowerBinding(binding) {
 		const ordinal = ordered.findIndex(function byName(candidate) {
 			return candidate.name === binding.field

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

@@ -20,12 +20,10 @@ 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) {

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 }
@@ -279,8 +228,8 @@ 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
-	const rosterA = "closed" in a.field ? a.field.closed : undefined
-	const rosterB = "closed" in b.field ? b.field.closed : undefined
+	const rosterA = rosterOf(a.field)
+	const rosterB = rosterOf(b.field)
 	return (
 		a.field.kind === b.field.kind &&
 		a.class === b.class &&
@@ -300,8 +249,9 @@ function fieldJoins(a: ClassedField, b: ClassedField): boolean {
 function renderFieldKind(slot: ClassedField): string {
 	const field = slot.field
 	let base: string = field.kind
-	if ("closed" in field) {
-		base = `u64 referencing ${field.closed.name}`
+	const roster = rosterOf(field)
+	if (roster !== undefined) {
+		base = `u64 referencing ${roster.name}`
 	}
 	if (field.kind === "bytes") {
 		base = `bytes<${field.width}>`
@@ -363,8 +313,7 @@ export type {
 	SetParam,
 	ShapeOf,
 	UnionToIntersection,
-	Var,
-	VarsRecord
+	Var
 }
 export {
 	fieldJoins,
@@ -375,7 +324,6 @@ export {
 	makeParam,
 	makeSetParam,
 	makeVar,
-	makeVars,
 	renderFieldKind,
 	term
 }