@bjornpagen/bumbledb 0.2.0 → 0.4.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/run.ts

@@ -8,12 +8,16 @@
  * 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 { taggedCmpLiteral } from "#query/lower.ts"
@@ -45,10 +49,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 +107,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 +122,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

@@ -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,66 +222,102 @@ 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
 
 /** 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 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 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 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"]>,
+	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"]>,
+			RosterOf<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, 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.
  */
-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
+	const rosterA = "closed" in a.field ? a.field.closed : undefined
+	const rosterB = "closed" in b.field ? b.field.closed : undefined
+	return (
+		a.field.kind === b.field.kind &&
+		a.class === b.class &&
+		widthA === widthB &&
+		elementA === elementB &&
+		rosterA === rosterB
+	)
 }
 
 /**
- * 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 (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(field: AnyField): string {
+function renderFieldKind(slot: ClassedField): string {
+	const field = slot.field
 	let base: string = field.kind
+	if ("closed" in field) {
+		base = `u64 referencing ${field.closed.name}`
+	}
 	if (field.kind === "bytes") {
 		base = `bytes<${field.width}>`
 	}
 	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}`
 }
 
 /**
  * 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.
@@ -230,18 +334,22 @@ 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 {
 	AnyTerm,
-	DomainOf,
+	ClassedField,
 	Duration,
 	EnvShape,
 	Flatten,
@@ -255,7 +363,8 @@ export type {
 	SetParam,
 	ShapeOf,
 	UnionToIntersection,
-	Var
+	Var,
+	VarsRecord
 }
 export {
 	fieldJoins,
@@ -266,6 +375,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. */