@bjornpagen/bumbledb 0.19.1 → 0.19.2

package/src/face.ts

@@ -1,6 +1,7 @@
 import * as errors from "@superbuilders/errors"
 import type { AnyClosed, AnySelectedClosed, PayloadField } from "#closed.ts"
-import type { AnyField } from "#fields.ts"
+import type { AnyField, SignatureOf } from "#fields.ts"
+import type { Same } from "#judgment.ts"
 import type { AnyRelation, AnySelected, FieldsShape, RelationFields, SelectionBinding } from "#relation.ts"
 import { renderLiteralSet } from "#spec.ts"
 
@@ -46,24 +47,25 @@ type FaceFields<S extends FaceSource> = S extends AnySelected
 				? "id" | (keyof Row & string)
 				: never
 
-type ShapeOf<F extends AnyField> = readonly [
-	F["kind"],
-	F extends { readonly element: unknown } ? undefined : F extends { readonly width: infer W } ? W : undefined,
-	F extends { readonly element: infer E } ? E : undefined,
-	F extends {
-		readonly closed: { readonly name: infer N extends string; readonly handles: readonly (infer H extends string)[] }
-	}
-		? readonly [N, H]
-		: undefined
-]
+/**
+ * The wire shape a face projects: the field's {@link SignatureOf} with an
+ * interval's width erased. A fixed-width interval pairs with a plain one —
+ * width is a measure label, not wire structure. Bytes width IS wire
+ * structure and stays. The roster stays the full handle vector.
+ */
+type ProjectedSignature<F extends AnyField> = F extends { readonly kind: "interval" }
+	? readonly [F["kind"], undefined, F extends { readonly element: infer E } ? E : undefined, undefined]
+	: SignatureOf<F>
 
-type ShapeIn<Fields extends FieldsShape, K extends string> = K extends keyof Fields ? ShapeOf<Fields[K]> : undefined
+type ShapeIn<Fields extends FieldsShape, K extends string> = K extends keyof Fields
+	? ProjectedSignature<Fields[K]>
+	: undefined
 
 type ProjectedShape<S extends FaceSource, K extends string> = S extends AnySelected
 	? ShapeIn<RelationFields<S["relation"]>, K>
 	: S extends AnySelectedClosed
 		? K extends "id"
-			? ShapeOf<S["relation"]["id"]>
+			? ProjectedSignature<S["relation"]["id"]>
 			: ShapeIn<S["relation"]["columns"], K>
 		: S extends AnyRelation
 			? ShapeIn<RelationFields<S>, K>
@@ -72,7 +74,7 @@ type ProjectedShape<S extends FaceSource, K extends string> = S extends AnySelec
 						readonly columns: infer Cols extends Record<string, PayloadField>
 					}
 				? K extends "id"
-					? ShapeOf<Id>
+					? ProjectedSignature<Id>
 					: ShapeIn<Cols, K>
 				: undefined
 
@@ -92,11 +94,7 @@ interface FaceArityMismatch<Left, Right> {
 }
 
 type SameArity<A extends AnyFace, B extends AnyFace> =
-	Arity<A> extends Arity<B>
-		? Arity<B> extends Arity<A>
-			? unknown
-			: FaceArityMismatch<Arity<A>, Arity<B>>
-		: FaceArityMismatch<Arity<A>, Arity<B>>
+	Same<Arity<A>, Arity<B>> extends true ? unknown : FaceArityMismatch<Arity<A>, Arity<B>>
 
 interface FaceShapeMismatch<Left, Right> {
 	readonly "face shape mismatch — positionwise kind, width, element, and closed roster must be equal on both sides": readonly [
@@ -106,11 +104,7 @@ interface FaceShapeMismatch<Left, Right> {
 }
 
 type SameShapes<A extends AnyFace, B extends AnyFace> =
-	FaceShapes<A> extends FaceShapes<B>
-		? FaceShapes<B> extends FaceShapes<A>
-			? unknown
-			: FaceShapeMismatch<FaceShapes<A>, FaceShapes<B>>
-		: FaceShapeMismatch<FaceShapes<A>, FaceShapes<B>>
+	Same<FaceShapes<A>, FaceShapes<B>> extends true ? unknown : FaceShapeMismatch<FaceShapes<A>, FaceShapes<B>>
 
 function on<S extends FaceSource, const F extends FaceFields<S>>(source: S, field: F): Face<S, readonly [F]>
 function on<S extends FaceSource, const P extends readonly [FaceFields<S>, ...FaceFields<S>[]]>(

package/src/fields.ts

@@ -32,11 +32,22 @@ function span(start: bigint, end: bigint): IntervalValue {
 	return Object.freeze({ start, end })
 }
 
-interface ClosedRoster<Name extends string = string, H extends string = string> {
+/**
+ * Nonempty declaration-order handle vector — the ONE roster carrier. The
+ * handle union is `Handles[number]`, the ordinal of a handle is its tuple
+ * position, and the roster size is the tuple length. An empty vocabulary
+ * is unspellable.
+ */
+type ClosedHandleTuple = readonly [string, ...string[]]
+
+interface ClosedRoster<Name extends string, Handles extends ClosedHandleTuple> {
 	readonly name: Name
-	readonly handles: readonly H[]
+	readonly handles: Handles
 }
 
+/** The roster top type — what an erased carrier knows about any roster. */
+type AnyClosedRoster = ClosedRoster<string, ClosedHandleTuple>
+
 interface BoolField {
 	readonly kind: "bool"
 }
@@ -73,12 +84,42 @@ interface IntervalField<
 	readonly width: Width
 }
 
-interface ClosedIdField<Name extends string = string, H extends string = string> {
+interface ClosedIdField<Name extends string, Handles extends ClosedHandleTuple> {
 	readonly kind: "u64"
-	readonly closed: ClosedRoster<Name, H>
+	readonly closed: ClosedRoster<Name, Handles>
 }
 
-type AnyField = BoolField | StrField | U64Field | FreshU64Field | I64Field | BytesField | IntervalField | ClosedIdField
+/** The closed-id top type — the erased carrier's view of any closed id. */
+type AnyClosedIdField = ClosedIdField<string, ClosedHandleTuple>
+
+type AnyField =
+	| BoolField
+	| StrField
+	| U64Field
+	| FreshU64Field
+	| I64Field
+	| BytesField
+	| IntervalField
+	| AnyClosedIdField
+
+/**
+ * The ONE structural interpreter of a field descriptor — the positional
+ * signature every equality judgment reads (the positive join wall in
+ * `#query/scope.ts` and the face pairing wall in `#face.ts`). Two fields
+ * are one shape exactly when their signatures are the same tuple: kind,
+ * width, interval element, and the roster as name plus the handle VECTOR
+ * (order and length carry meaning; a set would forget both).
+ */
+type SignatureOf<F extends AnyField> = readonly [
+	F["kind"],
+	F extends { readonly width: infer W } ? W : undefined,
+	F extends { readonly element: infer E } ? E : undefined,
+	F extends {
+		readonly closed: { readonly name: infer N extends string; readonly handles: infer H extends ClosedHandleTuple }
+	}
+		? readonly [N, H]
+		: undefined
+]
 
 type Infer<F extends AnyField> = F extends { readonly kind: "bool" }
 	? boolean
@@ -106,13 +147,44 @@ function literalShapeError(context: string, expected: string, value: unknown): E
 	return errors.new(`${context}: expected ${expected}, got ${typeof value}`)
 }
 
-function rosterOf(field: AnyField | undefined): ClosedRoster | undefined {
+function rosterOf(field: AnyField | undefined): AnyClosedRoster | undefined {
 	if (field !== undefined && "closed" in field) {
 		return field.closed
 	}
 	return undefined
 }
 
+/**
+ * The runtime twin of roster equality inside {@link SignatureOf}: same
+ * vocabulary name, same handle vector (order and length). Two absent
+ * rosters agree; a roster never agrees with a bare field.
+ */
+function rostersAgree(a: AnyClosedRoster | undefined, b: AnyClosedRoster | undefined): boolean {
+	if (a === undefined || b === undefined) {
+		return a === b
+	}
+	return (
+		a.name === b.name &&
+		a.handles.length === b.handles.length &&
+		a.handles.every(function sameHandle(handle, index) {
+			return handle === b.handles[index]
+		})
+	)
+}
+
+/**
+ * The runtime twin of {@link SignatureOf} equality — the ONE spelling of
+ * "these two descriptors are one shape". Kind, width, interval element,
+ * and the roster vector must all agree.
+ */
+function signaturesAgree(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 && widthA === widthB && elementA === elementB && rostersAgree(rosterOf(a), rosterOf(b))
+}
+
 function isIntervalValue(value: unknown): value is IntervalValue {
 	return (
 		typeof value === "object" &&
@@ -124,7 +196,7 @@ function isIntervalValue(value: unknown): value is IntervalValue {
 	)
 }
 
-function handleLiteral(closed: ClosedRoster, value: unknown): LiteralSpec {
+function handleLiteral(closed: AnyClosedRoster, value: unknown): LiteralSpec {
 	if (typeof value !== "string") {
 		throw literalShapeError("selection literal", `a ${closed.name} handle name (string)`, value)
 	}
@@ -245,9 +317,12 @@ function literalOf(field: AnyField, value: unknown): LiteralSpec {
 }
 
 export type {
+	AnyClosedIdField,
+	AnyClosedRoster,
 	AnyField,
 	BoolField,
 	BytesField,
+	ClosedHandleTuple,
 	ClosedIdField,
 	ClosedRoster,
 	FreshU64Field,
@@ -255,6 +330,7 @@ export type {
 	Infer,
 	IntervalField,
 	IntervalValue,
+	SignatureOf,
 	StrField,
 	U64Field
 }
@@ -269,6 +345,8 @@ export {
 	literalOf,
 	literalShapeError,
 	rosterOf,
+	rostersAgree,
+	signaturesAgree,
 	span,
 	str,
 	u64

package/src/index.ts

@@ -100,9 +100,12 @@ export type {
 } from "#face.ts"
 export { on } from "#face.ts"
 export type {
+	AnyClosedIdField,
+	AnyClosedRoster,
 	AnyField,
 	BoolField,
 	BytesField,
+	ClosedHandleTuple,
 	ClosedIdField,
 	ClosedRoster,
 	FreshU64Field,
@@ -110,10 +113,12 @@ export type {
 	Infer,
 	IntervalField,
 	IntervalValue,
+	SignatureOf,
 	StrField,
 	U64Field
 } from "#fields.ts"
 export { bool, bytes, i64, interval, span, str, u64 } from "#fields.ts"
+export type { Same, SameLen } from "#judgment.ts"
 export type { ClassesOf, ClassWall, LawfulStatements, RelationClasses, SchemaClasses } from "#law.ts"
 export { lower } from "#lower.ts"
 export type { KeyFact } from "#marshal.ts"

package/src/judgment.ts

@@ -0,0 +1,25 @@
+/**
+ * The type-level judgment kernel. Two primitives, no imports, no runtime.
+ *
+ * {@link Same} is definitional equality by mutual extension — the ONE
+ * spelling of `A = B` at the type tier. {@link SameLen} is Peano equality
+ * on tuple lengths — zero equals zero, successor recurses on successor,
+ * everything else is refused. An open array carries no Nat (its length is
+ * `number`), so it proves nothing.
+ */
+
+type Same<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false
+
+type SameLen<A extends readonly unknown[], B extends readonly unknown[]> = number extends A["length"]
+	? false
+	: number extends B["length"]
+		? false
+		: A extends readonly [unknown, ...infer ARest]
+			? B extends readonly [unknown, ...infer BRest]
+				? SameLen<ARest, BRest>
+				: false
+			: B extends readonly [unknown, ...unknown[]]
+				? false
+				: true
+
+export type { Same, SameLen }

package/src/law.ts

@@ -58,6 +58,7 @@ import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import { isClosedMember, sealedFieldsOf } from "#closed.ts"
 import type { FaceData } from "#face.ts"
+import type { Same } from "#judgment.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
 import type { SchemaRelation, SchemaRelations } from "#schema.ts"
 import { renderStatement, type Statement } from "#statements.ts"
@@ -196,7 +197,7 @@ type WallScan<Comps extends readonly string[], Gens extends string, Pairs extend
 		: WallScan<T, Gens, Pairs>
 	: unknown
 
-type SetEq<A extends string, B extends string> = [A] extends [B] ? ([B] extends [A] ? true : false) : false
+type SetEq<A extends string, B extends string> = Same<A, B>
 
 type KeyEntry = readonly [string, string]
 

package/src/marshal.ts

@@ -28,7 +28,7 @@
  */
 
 import * as errors from "@superbuilders/errors"
-import type { AnyField, ClosedRoster } from "#fields.ts"
+import type { AnyClosedRoster, AnyField } from "#fields.ts"
 import { isIntervalValue, literalShapeError, rosterOf } from "#fields.ts"
 import type { FactValue } from "#native.ts"
 import type { AnyRelation, Fact, FreshKeys, RelationData } from "#relation.ts"
@@ -61,7 +61,7 @@ function isStringIndexed(value: object): value is Readonly<Record<string, unknow
  * violation. `indexOf` is the whole machine (the roster is ≤ 256 rows,
  * engine law — no map is warranted).
  */
-function closedCellOf(context: string, closed: ClosedRoster, name: string): FactValue {
+function closedCellOf(context: string, closed: AnyClosedRoster, name: string): FactValue {
 	const id = closed.handles.indexOf(name)
 	if (id === -1) {
 		throw errors.new(
@@ -71,7 +71,7 @@ function closedCellOf(context: string, closed: ClosedRoster, name: string): Fact
 	return BigInt(id)
 }
 
-function handleOf(context: string, closed: ClosedRoster, cell: FactValue): string {
+function handleOf(context: string, closed: AnyClosedRoster, cell: FactValue): string {
 	if (typeof cell !== "bigint") {
 		throw literalShapeError(context, `a ${closed.name} handle id (bigint)`, cell)
 	}

package/src/query/atom.ts

@@ -1,5 +1,5 @@
 import * as errors from "@superbuilders/errors"
-import type { AnyField, ClosedIdField, ClosedRoster, Infer, IntervalValue } from "#fields.ts"
+import type { AnyClosedRoster, AnyField, Infer, IntervalValue } from "#fields.ts"
 import type { ClassLookup, ClassRecordOf, SchemaClasses } from "#law.ts"
 import type {
 	AntiJoinOk,
@@ -77,7 +77,7 @@ type FindEntryData =
 interface FindColumn {
 	readonly name: string
 	readonly entry: FindEntryData
-	readonly closed: ClosedRoster | undefined
+	readonly closed: AnyClosedRoster | undefined
 	readonly slot: ClassedField | undefined
 }
 
@@ -140,7 +140,7 @@ type DerivedTable = InteriorData | RecHead
 
 type BindingInput<F extends AnyField> =
 	| Infer<F>
-	| (F extends ClosedIdField ? readonly Infer<F>[] : never)
+	| (F extends { readonly closed: { readonly handles: readonly string[] } } ? readonly Infer<F>[] : never)
 	| (F extends { readonly kind: "interval" } ? bigint : never)
 	| AnyVar
 	| Param<string>
@@ -364,7 +364,7 @@ function not(
  * closed-bound terms — the construction-time validations in
  * `#query/lower.ts` are that ban's runtime twin.
  */
-type NumericVarOk<V extends AnyVar> = V["field"] extends { readonly closed: ClosedRoster }
+type NumericVarOk<V extends AnyVar> = V["field"] extends { readonly closed: AnyClosedRoster }
 	? false
 	: V["field"]["kind"] extends "u64" | "i64"
 		? true

package/src/query/lower.ts

@@ -1,6 +1,6 @@
 import * as errors from "@superbuilders/errors"
 import { sealedFieldsOf } from "#closed.ts"
-import type { AnyField, ClosedRoster } from "#fields.ts"
+import type { AnyClosedRoster, AnyField } from "#fields.ts"
 import { assertDeclarationOrderKey, isIntervalValue, literalShapeError, rosterOf } from "#fields.ts"
 import type { ClassRecordOf, SchemaClasses } from "#law.ts"
 import type {
@@ -1171,7 +1171,7 @@ function makeRecRuleScope<Rels extends SchemaRelations, Classes extends SchemaCl
 	return raw
 }
 
-function renderClosedSlice(closed: ClosedRoster | undefined): string {
+function renderClosedSlice(closed: AnyClosedRoster | undefined): string {
 	return closed === undefined ? "a bare value" : `a ${closed.name} reference`
 }
 
@@ -1187,7 +1187,7 @@ function headSignature(column: FindColumn): string {
 	return `${column.name}:${agg.op}`
 }
 
-function renderParamAnchor(roster: ClosedRoster | undefined): string {
+function renderParamAnchor(roster: AnyClosedRoster | undefined): string {
 	return roster === undefined ? "a non-closed position" : `a ${roster.name} reference`
 }
 

package/src/query/scope.ts

@@ -1,8 +1,9 @@
 import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import { sealedFieldsOf } from "#closed.ts"
-import type { AnyField, Infer } from "#fields.ts"
-import { rosterOf } from "#fields.ts"
+import type { AnyField, Infer, SignatureOf } from "#fields.ts"
+import { rosterOf, signaturesAgree } from "#fields.ts"
+import type { Same, SameLen } from "#judgment.ts"
 import type { ClassLookup, ClassRecordOf, SchemaClasses } from "#law.ts"
 import type { QueryParam } from "#native.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
@@ -19,7 +20,7 @@ type MatchFields<R extends MatchOwner> = R extends AnyClosed
 		? RelationFields<R>
 		: never
 
-interface Var<F extends AnyField = AnyField, RN extends string = string, K extends string = string> {
+interface Var<F extends AnyField, RN extends string, K extends string> {
 	readonly [term]: "var"
 	readonly owner: MatchOwner & { readonly name: RN }
 	readonly column: K
@@ -27,19 +28,19 @@ interface Var<F extends AnyField = AnyField, RN extends string = string, K exten
 	readonly label: string
 }
 
-type AnyVar = Var
+type AnyVar = Var<AnyField, string, string>
 
-interface Param<Name extends string = string> {
+interface Param<Name extends string> {
 	readonly [term]: "param"
 	readonly name: Name
 }
 
-interface SetParam<Name extends string = string> {
+interface SetParam<Name extends string> {
 	readonly [term]: "setParam"
 	readonly name: Name
 }
 
-type AnyTerm = Var | Param | SetParam
+type AnyTerm = AnyVar | Param<string> | SetParam<string>
 
 function isTerm(value: unknown): value is AnyTerm {
 	return typeof value === "object" && value !== null && term in value
@@ -147,81 +148,75 @@ type UnionToIntersection<U> = (U extends unknown ? (member: U) => void : never)
 
 type ShapeOf<U> = [U] extends [never] ? Record<never, never> : Flatten<UnionToIntersection<U>>
 
-type WidthOf<F extends AnyField> = F extends { readonly width: infer W } ? W : undefined
-
-type ElementOf<F extends AnyField> = F extends { readonly element: infer E } ? E : undefined
+/**
+ * A slot's identity for the positive-join judgment: the field's structural
+ * signature ({@link SignatureOf} — the ONE interpreter, shared with the
+ * face pairing wall) plus the slot's law class.
+ */
+type SlotSignature<S extends ClassedField> = readonly [SignatureOf<S["field"]>, S["class"]]
 
-type RosterOf<F extends AnyField> = F extends {
-	readonly closed: { readonly name: infer N extends string; readonly handles: readonly (infer H extends string)[] }
-}
-	? readonly [N, H]
-	: undefined
-
-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
+type JoinOk<A extends ClassedField, B extends ClassedField> = Same<SlotSignature<A>, SlotSignature<B>>
 
 type U64Wire<F extends AnyField> = F extends { readonly kind: "u64" }
-	? RosterOf<F> extends undefined
-		? true
-		: false
+	? F extends { readonly closed: unknown }
+		? false
+		: true
 	: false
 
+type ClosedHandles<F extends AnyField> = F extends {
+	readonly closed: { readonly handles: infer H extends readonly string[] }
+}
+	? H
+	: never
+
+/**
+ * Two closed ids anti-join when their handle vectors carry the same Peano
+ * length ({@link SameLen}: zero equals zero, successor recurses on
+ * successor). A bare field has no vector and proves nothing.
+ */
+type ClosedIdOk<A extends AnyField, B extends AnyField> = [ClosedHandles<A>] extends [never]
+	? false
+	: [ClosedHandles<B>] extends [never]
+		? false
+		: SameLen<ClosedHandles<A>, ClosedHandles<B>>
+
 /**
  * Anti-join class safety: class-equal slots, plus same-identity u64
- * (fresh mint, foreign-key copy, or bare u64) when one side is bare.
- * Two distinct generators stay refused. Closed-roster u64 is not a
- * wire identity.
+ * (fresh mint, foreign-key copy, or bare u64) when one side is bare,
+ * plus two closed-id fields whose handle tuples have the same length.
+ * Two distinct generators stay refused.
  */
 type AntiJoinOk<A extends ClassedField, B extends ClassedField> =
 	JoinOk<A, B> extends true
 		? true
-		: U64Wire<A["field"]> extends true
-			? U64Wire<B["field"]> extends true
-				? [A["class"]] extends [undefined]
-					? true
-					: [B["class"]] extends [undefined]
+		: ClosedIdOk<A["field"], B["field"]> extends true
+			? true
+			: U64Wire<A["field"]> extends true
+				? U64Wire<B["field"]> extends true
+					? [A["class"]] extends [undefined]
 						? true
-						: false
+						: [B["class"]] extends [undefined]
+							? true
+							: false
+					: false
 				: false
-			: false
 
 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 = 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
-	)
+	return a.class === b.class && signaturesAgree(a.field, b.field)
 }
 
 function u64Wire(field: AnyField): boolean {
 	return field.kind === "u64" && rosterOf(field) === undefined
 }
 
+function closedIdAntiJoins(a: AnyField, b: AnyField): boolean {
+	const rosterA = rosterOf(a)
+	const rosterB = rosterOf(b)
+	return rosterA !== undefined && rosterB !== undefined && rosterA.handles.length === rosterB.handles.length
+}
+
 function fieldAntiJoins(a: ClassedField, b: ClassedField): boolean {
-	if (fieldJoins(a, b)) {
+	if (fieldJoins(a, b) || closedIdAntiJoins(a.field, b.field)) {
 		return true
 	}
 	return u64Wire(a.field) && u64Wire(b.field) && (a.class === undefined || b.class === undefined)

package/src/statements.ts

@@ -12,7 +12,7 @@ import {
 } from "#capacity.ts"
 import { isClosedMember, sealedFieldOf } from "#closed.ts"
 import { type AnyFace, type FaceData, renderFace, type SameArity, type SameShapes } from "#face.ts"
-import { type ClosedRoster, rosterOf } from "#fields.ts"
+import { type AnyClosedRoster, rosterOf, rostersAgree } from "#fields.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
 import { type CapacityWindowSpec, renderCapacityWindow, renderWeight, type WeightSpec } from "#spec.ts"
 
@@ -67,7 +67,7 @@ interface KeyStatement<R extends AnyRelation, Projection extends readonly string
 	readonly data: KeyData<R, Projection>
 }
 
-function renderRosterSide(roster: ClosedRoster | undefined): string {
+function renderRosterSide(roster: AnyClosedRoster | undefined): string {
 	return roster === undefined ? "a bare column" : `a ${roster.name} reference`
 }
 
@@ -96,7 +96,7 @@ function assertRosterAgreement(source: FaceData, target: FaceData, statement: St
 		}
 		const sourceRoster = rosterOf(sealedFieldOf(source.owner, fieldName))
 		const targetRoster = rosterOf(sealedFieldOf(target.owner, targetField))
-		if (sourceRoster !== targetRoster) {
+		if (!rostersAgree(sourceRoster, targetRoster)) {
 			throw errors.new(
 				`${source.owner.name}.${fieldName} is ${renderRosterSide(sourceRoster)} but ${target.owner.name}.${targetField} is ${renderRosterSide(targetRoster)} — closedness rides the descriptor: a closed reference is spelled with the vocabulary's own id descriptor (one meaning, one spelling), so faces pair closed-with-closed through one roster or bare-with-bare, never across — ${renderStatement(statement)}`
 			)