@bjornpagen/bumbledb 0.19.1 → 0.20.0

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/db.ts

@@ -367,6 +367,13 @@ interface Db<Rels extends SchemaRelations> {
 	write<R>(fn: (tx: WriteTx<Rels>) => SyncResult<R>): WriteOutcome<Rels, SyncResult<R>>
 
 	writeFrom<R>(witness: Witness<Rels>, fn: (tx: WriteTx<Rels>) => SyncResult<R>): WriteFromOutcome<Rels, SyncResult<R>>
+	/**
+	 * blake3 over the canonical catalog enumeration — the replication
+	 * equality oracle: equal digests imply identical judged content
+	 * regardless of page layout or allocation history. Harness-tier
+	 * (bounded sequential passes over the store), off any hot path.
+	 */
+	catalogDigest(): Uint8Array
 	/**
 	 * Prepares a query value built against THIS schema (identity is the
 	 * membership rule): lowers it to the engine IR, pins the plan, and
@@ -1288,6 +1295,12 @@ function openDb<Rels extends SchemaRelations>(handle: DbHandle, theory: Schema<R
 		}, fn)
 	}
 
+	function catalogDigest(): Uint8Array {
+		return bridged("bumbledb catalog digest", function readCatalogDigest() {
+			return native.dbCatalogDigest(handle)
+		})
+	}
+
 	function prepare<Row, Params extends ParamsRecord>(q: Query<Rels, Row, Params>): Prepared<Rels, Row, Params> {
 		if (q.schema !== theory) {
 			throw errors.new(
@@ -1309,6 +1322,7 @@ function openDb<Rels extends SchemaRelations>(handle: DbHandle, theory: Schema<R
 		read,
 		write,
 		writeFrom,
+		catalogDigest,
 		prepare
 	})
 }
@@ -1668,6 +1682,7 @@ export type {
 	AbandonedArm,
 	Admission,
 	CapacityViolation,
+	CollectionWrite,
 	Committed,
 	ContainmentViolation,
 	DeclaredKeyFact,

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

@@ -47,6 +47,7 @@ export type {
 	AbandonedArm,
 	Admission,
 	CapacityViolation,
+	CollectionWrite,
 	Committed,
 	ContainmentViolation,
 	DeclaredKeyFact,
@@ -100,9 +101,12 @@ export type {
 } from "#face.ts"
 export { on } from "#face.ts"
 export type {
+	AnyClosedIdField,
+	AnyClosedRoster,
 	AnyField,
 	BoolField,
 	BytesField,
+	ClosedHandleTuple,
 	ClosedIdField,
 	ClosedRoster,
 	FreshU64Field,
@@ -110,15 +114,38 @@ 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"
+export { factOf, rowOf } from "#marshal.ts"
 export type {
 	FactValue,
+	LogBatch,
+	LogBatchDecodeKind,
+	LogBatchEncodeKind,
+	LogBatchHeader,
+	LogBraidComponent,
+	LogBraids,
+	LogChain,
+	LogChainEntry,
+	LogCheckpointDoc,
+	LogCheckpointHead,
+	LogCheckpointKind,
+	LogCodecHandle,
+	LogManifestDoc,
+	LogManifestKind,
+	LogOpIn,
+	LogOpKind,
+	LogOpOut,
+	LogPendingBatch,
+	LogResult,
+	LogSidecarKind,
 	ParsedQuery,
 	QueryIr,
 	SealedDescriptor,
@@ -128,7 +155,22 @@ export type {
 	SealedWeight,
 	StatementKindTag
 } from "#native.ts"
-export { internalBlake3, internalDescriptor } from "#native.ts"
+export {
+	internalBlake3,
+	internalDescriptor,
+	internalLogBraidsOf,
+	internalLogCodec,
+	internalLogDecodeBatch,
+	internalLogEncodeBatch,
+	internalLogParseCheckpoint,
+	internalLogParseCkptScratch,
+	internalLogParseManifest,
+	internalLogParseSidecar,
+	internalLogRenderCheckpoint,
+	internalLogRenderCkptScratch,
+	internalLogRenderManifest,
+	internalLogRenderSidecar
+} from "#native.ts"
 
 export type {
 	AnyCond,

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 }