@bjornpagen/bumbledb 0.19.0 → 0.19.2

package/src/closed.ts

@@ -1,8 +1,10 @@
 import * as errors from "@superbuilders/errors"
 import {
+	type AnyClosedIdField,
 	type AnyField,
 	assertDeclarationOrderKey,
 	assertDeclarationRecord,
+	type ClosedHandleTuple,
 	type ClosedIdField,
 	type ClosedRoster,
 	type Infer,
@@ -39,20 +41,28 @@ type Axioms<Handles extends string, Cols extends Record<string, PayloadField>> =
 	readonly [H in Handles]: AxiomRow<Cols>
 }
 
-interface ClosedCore<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> {
+interface ClosedCore<
+	Name extends string,
+	Handles extends ClosedHandleTuple,
+	Cols extends Record<string, PayloadField>
+> {
 	readonly name: Name
 
 	readonly id: ClosedIdField<Name, Handles>
 	readonly data: ClosedData
 
-	readonly axioms: Axioms<Handles, Cols>
+	readonly axioms: Axioms<Handles[number], Cols>
 
 	readonly columns: Cols
 }
 
 type ClosedSelectionInput<Cols extends Record<string, PayloadField>> = SelectionInput<Cols>
 
-interface SelectedClosed<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> {
+interface SelectedClosed<
+	Name extends string,
+	Handles extends ClosedHandleTuple,
+	Cols extends Record<string, PayloadField>
+> {
 	readonly relation: Closed<Name, Handles, Cols>
 	readonly selection: readonly SelectionBinding[]
 }
@@ -62,11 +72,15 @@ interface AnySelectedClosed {
 	readonly selection: readonly SelectionBinding[]
 }
 
-interface ClosedSelectable<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> {
+interface ClosedSelectable<
+	Name extends string,
+	Handles extends ClosedHandleTuple,
+	Cols extends Record<string, PayloadField>
+> {
 	where(selection: ClosedSelectionInput<Cols>): SelectedClosed<Name, Handles, Cols>
 }
 
-type Closed<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> = [
+type Closed<Name extends string, Handles extends ClosedHandleTuple, Cols extends Record<string, PayloadField>> = [
 	keyof Cols
 ] extends [never]
 	? ClosedCore<Name, Handles, Cols>
@@ -74,7 +88,7 @@ type Closed<Name extends string, Handles extends string, Cols extends Record<str
 
 interface AnyClosed {
 	readonly name: string
-	readonly id: ClosedIdField
+	readonly id: AnyClosedIdField
 	readonly data: ClosedData
 	readonly axioms: Readonly<Record<string, object>>
 	readonly columns: Readonly<Record<string, PayloadField>>
@@ -98,25 +112,34 @@ function sealedFieldOf(member: AnyRelation | AnyClosed, fieldName: string): AnyF
 	return declared?.field
 }
 
-function isHandleTuple(
-	shape: readonly [string, ...string[]] | Record<string, PayloadField>
-): shape is readonly [string, ...string[]] {
-	return Array.isArray(shape)
+function isHandleTuple(shape: unknown): shape is ClosedHandleTuple {
+	return (
+		Array.isArray(shape) &&
+		shape.length > 0 &&
+		shape.every(function stringHandle(handle) {
+			return typeof handle === "string"
+		})
+	)
 }
 
 /**
- * The trusted seam of the payload tier's handle enumeration: the axioms
- * record's own enumerable keys ARE its handle set (the type says so —
- * {@link Axioms} is keyed by the handles), and this guard verifies exactly
- * that checkable fact before the key list is admitted at the handle type.
+ * The trusted seam of the payload tier: the handle tuple and the axioms
+ * record are the same finite set — every tuple name is an own key, and
+ * every own key is in the tuple.
  */
 function handleKeysOwn<Handles extends string>(
 	axioms: { readonly [H in Handles]: object },
-	names: readonly string[]
-): names is readonly Handles[] {
-	return names.every(function ownHandle(name) {
-		return Object.hasOwn(axioms, name)
-	})
+	names: readonly Handles[]
+): boolean {
+	const listed = new Set<string>(names)
+	return (
+		names.every(function ownHandle(name) {
+			return Object.hasOwn(axioms, name)
+		}) &&
+		Object.keys(axioms).every(function listedHandle(name) {
+			return listed.has(name)
+		})
+	)
 }
 
 /**
@@ -160,40 +183,50 @@ function mintAxioms<Handles extends string, Cols extends Record<string, PayloadF
 	return out
 }
 
-function closed<const Name extends string, const Handles extends readonly [string, ...string[]]>(
+function closed<const Name extends string, const Handles extends ClosedHandleTuple>(
 	name: Name,
 	handles: Handles
-): Closed<Name, Handles[number], Record<never, never>>
+): Closed<Name, Handles, Record<never, never>>
 
-function closed<const Name extends string, const Cols extends PayloadColumns, Handles extends string>(
+function closed<const Name extends string, const Handles extends ClosedHandleTuple, const Cols extends PayloadColumns>(
 	name: Name,
+	handles: Handles,
 	columns: Cols,
-	axioms: Axioms<Handles, Cols>
+	axioms: Axioms<Handles[number], Cols>
 ): Closed<Name, Handles, Cols>
 
-function closed<const Name extends string, const Cols extends PayloadColumns, Handles extends string>(
+function closed<Name extends string, Handles extends ClosedHandleTuple, Cols extends PayloadColumns>(
 	name: Name,
-	shape: readonly [string, ...string[]] | Cols,
-	axioms?: Axioms<Handles, Cols>
-): Closed<Name, string, Record<never, never>> | Closed<Name, Handles, Cols> {
-	if (isHandleTuple(shape)) {
+	handles: Handles,
+	columns?: Cols,
+	axioms?: Axioms<Handles[number], Cols>
+): Closed<Name, Handles, Record<never, never>> | Closed<Name, Handles, Cols> {
+	if (!Array.isArray(handles)) {
+		throw errors.new(
+			`closed relation ${name}: payload columns declared without ground axioms — the payload tier is spelled closed(name, handles, columns, axioms)`
+		)
+	}
+	if (!isHandleTuple(handles)) {
+		throw errors.new(`closed relation ${name}: at least one handle is required (an empty vocabulary declares nothing)`)
+	}
+	if (columns === undefined) {
 		if (axioms !== undefined) {
 			throw errors.new(`closed relation ${name}: the bare tier declares no columns, so ground axioms are inadmissible`)
 		}
-		return closedBare(name, shape)
+		return closedBare(name, handles)
 	}
 	if (axioms === undefined) {
 		throw errors.new(
-			`closed relation ${name}: payload columns declared without ground axioms — the payload tier is spelled closed(name, columns, axioms) (the curried spelling is deleted)`
+			`closed relation ${name}: payload columns declared without ground axioms — the payload tier is spelled closed(name, handles, columns, axioms)`
 		)
 	}
-	return closedPayload(name, shape, axioms)
+	return closedPayload(name, handles, columns, axioms)
 }
 
-function closedBare<Name extends string, Handles extends string>(
+function closedBare<Name extends string, const Hs extends ClosedHandleTuple>(
 	name: Name,
-	handles: readonly [Handles, ...Handles[]]
-): Closed<Name, Handles, Record<never, never>> {
+	handles: Hs
+): Closed<Name, Hs, Record<never, never>> {
 	const empty: Record<string, object> = {}
 	for (const handle of handles) {
 		/** A duplicated name mints one row; the roster's own duplicate refusal in {@link mintClosed} stays the judge. */
@@ -202,33 +235,37 @@ function closedBare<Name extends string, Handles extends string>(
 		}
 	}
 	Object.freeze(empty)
-	if (!axiomsMinted<Handles, Record<never, never>>(empty, handles, [])) {
+	if (!axiomsMinted<Hs[number], Record<never, never>>(empty, handles, [])) {
 		throw errors.new(`closed relation ${name}: bare-tier axiom-row minting incomplete`)
 	}
-	return mintClosed<Name, Handles, Record<never, never>>(name, handles, {}, empty)
+	return mintClosed(name, handles, {}, empty)
 }
 
-function closedPayload<Name extends string, Handles extends string, Cols extends PayloadColumns>(
+function closedPayload<Name extends string, Handles extends ClosedHandleTuple, Cols extends PayloadColumns>(
 	name: Name,
+	handles: Handles,
 	columns: Cols,
-	axioms: Axioms<Handles, Cols>
+	axioms: Axioms<Handles[number], Cols>
 ): Closed<Name, Handles, Cols> {
 	assertDeclarationRecord(`closed relation ${name} columns`, columns)
 	for (const columnName of Object.keys(columns)) {
 		assertDeclarationOrderKey(`closed relation ${name} column`, columnName)
 	}
 	assertDeclarationRecord(`closed relation ${name} axioms`, axioms)
-	const handles = Object.keys(axioms)
 	for (const handle of handles) {
 		assertDeclarationOrderKey(`closed relation ${name} handle`, handle)
 	}
 	if (!handleKeysOwn(axioms, handles)) {
 		throw errors.new(`closed relation ${name}: handle enumeration incomplete`)
 	}
-	return mintClosed<Name, Handles, Cols>(name, handles, columns, axioms)
+	return mintClosed(name, handles, columns, axioms)
 }
 
-function surfaceMinted<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>>(
+function surfaceMinted<
+	Name extends string,
+	Handles extends ClosedHandleTuple,
+	Cols extends Record<string, PayloadField>
+>(
 	value: ClosedCore<Name, Handles, Cols>,
 	cols: readonly ClosedColumn[]
 ): value is ClosedCore<Name, Handles, Cols> & Closed<Name, Handles, Cols> {
@@ -236,16 +273,13 @@ function surfaceMinted<Name extends string, Handles extends string, Cols extends
 	return cols.length > 0 ? selectable : !selectable
 }
 
-function mintClosed<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>>(
+function mintClosed<Name extends string, Handles extends ClosedHandleTuple, Cols extends Record<string, PayloadField>>(
 	name: Name,
-	handles: readonly Handles[],
+	handles: Handles,
 	columns: Cols,
-	axioms: Axioms<Handles, Cols>
+	axioms: Axioms<Handles[number], Cols>
 ): Closed<Name, Handles, Cols> {
 	assertDeclarationOrderKey("closed relation", name)
-	if (handles.length === 0) {
-		throw errors.new(`closed relation ${name}: at least one handle is required (an empty vocabulary declares nothing)`)
-	}
 	const seen = new Set<string>()
 	for (const handle of handles) {
 		if (seen.has(handle)) {
@@ -253,7 +287,7 @@ function mintClosed<Name extends string, Handles extends string, Cols extends Re
 		}
 		seen.add(handle)
 	}
-	const handleList: readonly Handles[] = Object.freeze([...handles])
+	const handleList = Object.freeze(handles)
 	const roster: ClosedRoster<Name, Handles> = Object.freeze({ name, handles: handleList })
 	const cols: ClosedColumn[] = []
 	for (const [columnName, field] of Object.entries(columns)) {
@@ -266,7 +300,7 @@ function mintClosed<Name extends string, Handles extends string, Cols extends Re
 		cols.push(Object.freeze({ name: columnName, field }))
 	}
 	Object.freeze(cols)
-	const rows: ClosedRow[] = handleList.map(function lowerRow(handle) {
+	const rows: ClosedRow[] = handleList.map(function lowerRow(handle: Handles[number]) {
 		const row: Readonly<Record<string, unknown>> = axioms[handle]
 		const values = cols.map(function lowerAxiomLiteral(column) {
 			return Object.freeze(literalOf(column.field, row[column.name]))
@@ -281,7 +315,7 @@ function mintClosed<Name extends string, Handles extends string, Cols extends Re
 	})
 	const id: ClosedIdField<Name, Handles> = Object.freeze({ kind: "u64", closed: roster })
 
-	const axiomsOut = mintAxioms<Handles, Cols>(name, handleList, cols, axioms)
+	const axiomsOut = mintAxioms<Handles[number], Cols>(name, handleList, cols, axioms)
 	const columnsOut: Cols = { ...columns }
 	Object.freeze(columnsOut)
 	const holder: { value: Closed<Name, Handles, Cols> | undefined } = { value: undefined }
@@ -299,7 +333,7 @@ function mintClosed<Name extends string, Handles extends string, Cols extends Re
 	const core = { name, id, data, axioms: axiomsOut, columns: columnsOut }
 	const value: ClosedCore<Name, Handles, Cols> =
 		cols.length > 0 ? Object.freeze({ ...core, where }) : Object.freeze(core)
-	if (!surfaceMinted<Name, Handles, Cols>(value, cols)) {
+	if (!surfaceMinted(value, cols)) {
 		throw errors.new(`closed relation ${name}: ergonomic-surface minting incomplete`)
 	}
 	holder.value = value

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,7 +1,8 @@
 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,
 	AnyVar,
 	ClassedField,
 	JoinOk,
@@ -76,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
 }
 
@@ -139,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>
@@ -363,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
@@ -450,7 +451,7 @@ type EqOk<Classes extends SchemaClasses, L, R> = L extends AnyVar
 	: false
 
 type NotBindingOk<Classes extends SchemaClasses, S extends ClassedField, T> = T extends AnyVar
-	? JoinOk<MintSlotOf<Classes, T>, S> extends true
+	? AntiJoinOk<MintSlotOf<Classes, T>, S> extends true
 		? true
 		: false
 	: true