@bjornpagen/bumbledb 1.1.0 → 1.2.0

package/src/fields.ts

@@ -1,9 +1,8 @@
 import { regex } from "arkregex"
-import { Result } from "effect"
 import { AuthoringError } from "#errors.ts"
-import { DbError } from "#runtime-errors.ts"
 import type { LiteralSpec } from "#spec.ts"
-import { Uuid } from "#uuid.ts"
+import type { Uuid } from "#uuid.ts"
+import { arrayValue, fieldValue, recordValue, taggedValueOf, U64_MAX } from "#values.ts"
 
 const INTEGER_INDEX_NAME = regex("^(?:0|[1-9][0-9]*)$")
 
@@ -23,54 +22,15 @@ interface IntervalValue {
 /**
  * A half-open dense float interval `[start, end)` as a plain value object:
  * two canonical binary64 bounds on the dense numeric line.
- * NaN is never an endpoint, signed zero is normalized at the checked
- * constructor and again by the native boundary, and strict `start < end`
- * makes empty spans unrepresentable through {@link span}. Infinite bounds
- * denote a missing bound, not a member point.
+ * Field-directed validation rejects NaN endpoints and empty intervals and
+ * normalizes signed zero. Infinite bounds denote a missing bound, not a
+ * member point; a plain object alone is not evidence of validation.
  */
 interface FloatIntervalValue {
 	readonly start: number
 	readonly end: number
 }
 
-/**
- * Constructs a checked interval literal — the `start..end` spelling.
- * Half-open and nonempty by construction. Fallible pure parsing
- * returns `Result` (use `Effect.fromResult(span(...))` inside a generator),
- * never hidden I/O and never a thrown domain outcome.
- *
- * Two element domains, selected by argument type: `span(0n, 60n)` is a
- * discrete integer interval; `span(0.5, 1.5)` is a dense float interval
- * with canonical endpoints (NaN refused, `-0` normalized to `+0`,
- * `-Infinity` legal only as the lower bound and `+Infinity` only as the
- * upper bound — both enforced by strict numeric `start < end`).
- */
-function span(start: bigint, end: bigint): Result.Result<IntervalValue, DbError>
-function span(start: number, end: number): Result.Result<FloatIntervalValue, DbError>
-function span(
-	start: bigint | number,
-	end: bigint | number
-): Result.Result<IntervalValue, DbError> | Result.Result<FloatIntervalValue, DbError> {
-	if (typeof start === "bigint" && typeof end === "bigint") {
-		if (start >= end) {
-			return Result.fail(new DbError({ operation: "span", reason: { _tag: "InvalidArgument" } }))
-		}
-		return Result.succeed(Object.freeze({ start, end }))
-	}
-	if (typeof start === "number" && typeof end === "number") {
-		if (Number.isNaN(start) || Number.isNaN(end)) {
-			return Result.fail(new DbError({ operation: "span", reason: { _tag: "InvalidArgument" } }))
-		}
-		const lo = Object.is(start, -0) ? 0 : start
-		const hi = Object.is(end, -0) ? 0 : end
-		if (!(lo < hi)) {
-			return Result.fail(new DbError({ operation: "span", reason: { _tag: "InvalidArgument" } }))
-		}
-		return Result.succeed(Object.freeze({ start: lo, end: hi }))
-	}
-	return Result.fail(new DbError({ operation: "span", reason: { _tag: "InvalidArgument" } }))
-}
-
 /**
  * Nonempty declaration-order handle vector — the ONE roster carrier. The
  * handle union is `Handles[number]`, the ordinal of a handle is its tuple
@@ -187,11 +147,11 @@ type Infer<F extends AnyField> = F extends { readonly kind: "bool" }
 							? Uuid
 							: F extends { readonly kind: "bytes" }
 								? Uint8Array
-								: F extends { readonly kind: "interval"; readonly element: "f64" }
-									? FloatIntervalValue
-									: F extends { readonly kind: "interval" }
-										? IntervalValue
-										: never
+								: F extends { readonly kind: "interval"; readonly element: infer Element }
+									? Element extends "f64"
+										? FloatIntervalValue
+										: IntervalValue
+									: never
 
 /**
  * The typed shape refusal shared by every literal machine — the selection
@@ -263,47 +223,10 @@ function isFloatIntervalValue(value: unknown): value is FloatIntervalValue {
 	)
 }
 
-function handleLiteral(closed: AnyClosedRoster, value: unknown): LiteralSpec {
-	if (typeof value !== "string") {
-		throw literalShapeError("selection literal", `a ${closed.name} handle name (string)`, value)
-	}
-	if (!closed.handles.includes(value)) {
-		throw new AuthoringError({
-			message: `"${value}" is not a handle of ${closed.name} — the roster is ${closed.handles.join(", ")}`
-		})
-	}
-	return { kind: "handle", handle: value }
-}
-
-function intervalLiteral(element: IntervalElementKind, value: unknown): LiteralSpec {
-	if (element === "f64") {
-		if (!isFloatIntervalValue(value)) {
-			throw literalShapeError("selection literal", "float interval ({ start, end } numbers)", value)
-		}
-		if (Number.isNaN(value.start) || Number.isNaN(value.end) || !(value.start < value.end)) {
-			throw new AuthoringError({
-				message: "selection literal: a float interval is half-open and nonempty with non-NaN canonical endpoints"
-			})
-		}
-		return {
-			kind: "value",
-			value: {
-				kind: "intervalF64",
-				start: Object.is(value.start, -0) ? 0 : value.start,
-				end: Object.is(value.end, -0) ? 0 : value.end
-			}
-		}
-	}
-	if (!isIntervalValue(value)) {
-		throw literalShapeError("selection literal", "interval ({ start, end } bigints)", value)
-	}
-	if (element === "u64") {
-		return { kind: "value", value: { kind: "intervalU64", start: value.start, end: value.end } }
-	}
-	return { kind: "value", value: { kind: "intervalI64", start: value.start, end: value.end } }
-}
-
 function assertDeclarationOrderKey(where: string, name: string): void {
+	if (typeof name !== "string" || !name.isWellFormed()) {
+		throw new AuthoringError({ message: `${where}: expected a well-formed Unicode name` })
+	}
 	if (INTEGER_INDEX_NAME.test(name)) {
 		throw new AuthoringError({
 			message: `${where}: name ${name} is an integer index — JavaScript object keys re-order integer indices, breaking the declaration-order law; use a non-numeric name`
@@ -317,12 +240,92 @@ function assertDeclarationOrderKey(where: string, name: string): void {
 }
 
 function assertDeclarationRecord(where: string, record: object): void {
+	if (typeof record !== "object" || record === null) {
+		throw new AuthoringError({ message: `${where}: expected a plain declaration record` })
+	}
 	const proto = Object.getPrototypeOf(record)
 	if (proto !== Object.prototype && proto !== null) {
 		throw new AuthoringError({
 			message: `${where}: the declaration record's prototype was replaced — a plain \`__proto__: {...}\` entry is the prototype setter, so its key silently vanishes from the declaration; spell it computed (["__proto__"]: {...}) to declare it as data`
 		})
 	}
+	for (const key of Reflect.ownKeys(record)) {
+		const property = Object.getOwnPropertyDescriptor(record, key)
+		if (typeof key !== "string" || property?.enumerable !== true || !("value" in property)) {
+			throw new AuthoringError({ message: `${where}: declarations require enumerable own data fields` })
+		}
+	}
+}
+
+/** Own a checked roster; never freeze the caller's array. */
+function ownHandles<const H extends ClosedHandleTuple>(context: string, handles: H): H
+function ownHandles(context: string, handles: unknown): ClosedHandleTuple
+function ownHandles(context: string, handles: unknown): ClosedHandleTuple {
+	if (!Array.isArray(handles) || handles.length === 0) {
+		throw new AuthoringError({ message: `${context}: expected a nonempty handle tuple` })
+	}
+	const seen = new Set<string>()
+	const values = arrayValue(context, handles, (_, handle) => {
+		if (typeof handle !== "string") throw new AuthoringError({ message: `${context}: expected string handles` })
+		if (!handle.isWellFormed()) throw new AuthoringError({ message: `${context}: expected well-formed string handles` })
+		if (seen.has(handle)) throw new AuthoringError({ message: `${context}: duplicate handle ${handle}` })
+		seen.add(handle)
+		return handle
+	})
+	const first = values[0]
+	if (first === undefined) throw new AuthoringError({ message: `${context}: expected a nonempty handle tuple` })
+	return Object.freeze([first, ...values.slice(1)])
+}
+
+/** Checked structural field descriptors, shared by declaration boundaries. */
+function fieldDescriptor<F extends AnyField>(context: string, input: F): F
+function fieldDescriptor(context: string, input: unknown): AnyField
+function fieldDescriptor(context: string, input: unknown): AnyField {
+	if (typeof input !== "object" || input === null || !("kind" in input)) {
+		throw new AuthoringError({ message: `${context}: expected a field descriptor` })
+	}
+	assertDeclarationRecord(context, input)
+	switch (input.kind) {
+		case "bool":
+		case "str":
+		case "i64":
+		case "f64":
+		case "uuid":
+			recordValue(context, input, ["kind"])
+			return Object.freeze({ kind: input.kind })
+		case "u64": {
+			if (!("closed" in input)) {
+				recordValue(context, input, ["kind"])
+				return u64
+			}
+			recordValue(context, input, ["kind", "closed"])
+			const roster = recordValue(context, input.closed, ["name", "handles"])
+			if (typeof roster.name !== "string") throw new AuthoringError({ message: `${context}: expected a roster name` })
+			assertDeclarationOrderKey(context, roster.name)
+			return Object.freeze({
+				kind: "u64",
+				closed: Object.freeze({ name: roster.name, handles: ownHandles(context, roster.handles) })
+			})
+		}
+		case "bytes": {
+			const value = recordValue(context, input, ["kind", "width"])
+			if (typeof value.width !== "number") throw new AuthoringError({ message: `${context}: expected a bytes width` })
+			return bytes(value.width)
+		}
+		case "interval": {
+			const value = recordValue(context, input, ["kind", "element", "width"])
+			if (value.element !== "u64" && value.element !== "i64" && value.element !== "f64") {
+				throw new AuthoringError({ message: `${context}: expected an interval element kind` })
+			}
+			if (value.width === undefined) return interval({ kind: value.element })
+			if (value.element === "f64" || typeof value.width !== "bigint") {
+				throw new AuthoringError({ message: `${context}: only discrete intervals accept a bigint width` })
+			}
+			return interval({ kind: value.element }, value.width)
+		}
+		default:
+			throw new AuthoringError({ message: `${context}: unknown field kind` })
+	}
 }
 
 const u64: U64Field = Object.freeze({ kind: "u64" })
@@ -371,69 +374,19 @@ function interval(
 				"interval(f64) takes no width — a fixed-width float interval is unrepresentable (rounded start + width is not an exact fixed length on the dense line); applications supply two checked bounds"
 		})
 	}
-	if (width !== undefined && width < 1n) {
+	if (width !== undefined && (typeof width !== "bigint" || width < 1n || width > U64_MAX)) {
 		throw new AuthoringError({
-			message: `interval width must be >= 1 (got ${width}) — w >= 1 is pinned at declaration`
+			message: "interval width must be a bigint in 1..=u64::MAX"
 		})
 	}
 	return Object.freeze({ kind: "interval", element: elementKind, width })
 }
 
 function literalOf(field: AnyField, value: unknown): LiteralSpec {
-	const roster = rosterOf(field)
-	if (roster !== undefined) {
-		return handleLiteral(roster, value)
-	}
-	switch (field.kind) {
-		case "bool": {
-			if (typeof value !== "boolean") {
-				throw literalShapeError("selection literal", "boolean", value)
-			}
-			return { kind: "value", value: { kind: "bool", value } }
-		}
-		case "u64": {
-			if (typeof value !== "bigint") {
-				throw literalShapeError("selection literal", "bigint", value)
-			}
-			return { kind: "value", value: { kind: "u64", value } }
-		}
-		case "i64": {
-			if (typeof value !== "bigint") {
-				throw literalShapeError("selection literal", "bigint", value)
-			}
-			return { kind: "value", value: { kind: "i64", value } }
-		}
-		case "str": {
-			if (typeof value !== "string") {
-				throw literalShapeError("selection literal", "string", value)
-			}
-
-			if (!value.isWellFormed()) {
-				throw literalShapeError("selection literal", "well-formed string", value)
-			}
-			return { kind: "value", value: { kind: "string", value } }
-		}
-		case "f64": {
-			if (typeof value !== "number") {
-				throw literalShapeError("selection literal", "number", value)
-			}
-			return { kind: "value", value: { kind: "f64", value } }
-		}
-		case "uuid": {
-			if (!Uuid.isUuid(value)) {
-				throw literalShapeError("selection literal", "a UUID (canonical UUID text)", value)
-			}
-			return { kind: "value", value: { kind: "uuid", value } }
-		}
-		case "bytes": {
-			if (!(value instanceof Uint8Array)) {
-				throw literalShapeError("selection literal", "Uint8Array", value)
-			}
-			return { kind: "value", value: { kind: "fixedBytes", value } }
-		}
-		case "interval":
-			return intervalLiteral(field.element, value)
+	if ("closed" in field) {
+		return { kind: "handle", handle: fieldValue("selection literal", field, value) }
 	}
+	return { kind: "value", value: taggedValueOf("selection literal", field, value) }
 }
 
 export type {
@@ -463,16 +416,17 @@ export {
 	bool,
 	bytes,
 	f64,
+	fieldDescriptor,
 	i64,
 	interval,
 	isFloatIntervalValue,
 	isIntervalValue,
 	literalOf,
 	literalShapeError,
+	ownHandles,
 	rosterOf,
 	rostersAgree,
 	signaturesAgree,
-	span,
 	str,
 	u64,
 	uuid

package/src/immutable.ts

@@ -0,0 +1,76 @@
+/** Only frozen plain data graphs are stable cache keys. Typed-array contents
+ * remain mutable even behind a frozen parent, so they never qualify. */
+const immutable = new WeakSet<object>()
+
+function isImmutable(input: unknown, visiting = new WeakSet<object>()): boolean {
+	if (typeof input !== "object" || input === null) return typeof input !== "function"
+	if (immutable.has(input)) return true
+	const prototype = Object.getPrototypeOf(input)
+	if (
+		(prototype !== Object.prototype && prototype !== null && prototype !== Array.prototype) ||
+		!Object.isFrozen(input) ||
+		visiting.has(input)
+	)
+		return false
+	visiting.add(input)
+	for (const name of Reflect.ownKeys(input)) {
+		const property = Object.getOwnPropertyDescriptor(input, name)
+		if (property === undefined || !("value" in property) || !isImmutable(property.value, visiting)) {
+			visiting.delete(input)
+			return false
+		}
+	}
+	visiting.delete(input)
+	immutable.add(input)
+	return true
+}
+
+/** Validation is never skipped for a mutable structural input. Validated
+ * immutable outputs can be reused without requiring constructor identity. */
+function descriptorCache<A extends object>(parse: (input: unknown) => A): (input: unknown) => A {
+	const cache = new WeakMap<object, A>()
+	return (input) => {
+		if (typeof input === "object" && input !== null) {
+			const found = cache.get(input)
+			if (found !== undefined) return found
+		}
+		const result = parse(input)
+		if (isImmutable(result)) {
+			cache.set(result, result)
+			if (typeof input === "object" && input !== null && isImmutable(input)) cache.set(input, result)
+		}
+		return result
+	}
+}
+
+/** Detached inspection data: share proven immutable branches, copy byte
+ * buffers and their parents, and preserve references within one snapshot.
+ * This is for already checked internal data, not an input validator. */
+function snapshotData<A>(input: A, onCopy?: (source: object, snapshot: object) => void): A
+function snapshotData(input: unknown, onCopy?: (source: object, snapshot: object) => void): unknown {
+	const copied = new WeakMap<object, object>()
+	function visit(value: unknown): unknown {
+		if (typeof value !== "object" || value === null || isImmutable(value)) return value
+		const existing = copied.get(value)
+		if (existing !== undefined) return existing
+		if (value instanceof Uint8Array) {
+			const bytes = Uint8Array.from(value)
+			copied.set(value, bytes)
+			return bytes
+		}
+		const result = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value))
+		copied.set(value, result)
+		for (const name of Reflect.ownKeys(value)) {
+			if (Array.isArray(value) && name === "length") continue
+			const property = Object.getOwnPropertyDescriptor(value, name)
+			if (property === undefined || !("value" in property)) throw new TypeError("snapshotData requires checked data")
+			Object.defineProperty(result, name, { value: visit(property.value), enumerable: property.enumerable === true })
+		}
+		Object.freeze(result)
+		onCopy?.(value, result)
+		return result
+	}
+	return visit(input)
+}
+
+export { descriptorCache, isImmutable, snapshotData }

package/src/index.ts

@@ -16,40 +16,35 @@ export type {
 	WeightOnSource
 } from "#capacity.ts"
 export { duration, ref, weigh, within } from "#capacity.ts"
-export type { ChangeDraft } from "#changes.ts"
+export type { ChangeCounts, ChangeDraft, ChangeRecord } from "#changes.ts"
 export { ChangeSet } from "#changes.ts"
 export type {
 	AnyClosed,
-	AnySelectedClosed,
 	AxiomRow,
 	Axioms,
 	Closed,
-	ClosedColumn,
-	ClosedCore,
-	ClosedData,
-	ClosedRow,
-	ClosedSelectionInput,
-	PayloadField,
-	SelectedClosed
+	PayloadField
 } from "#closed.ts"
-export { closed } from "#closed.ts"
+export { closed, closedId } from "#closed.ts"
 export type { RowShape } from "#codec.ts"
 export { decodeBoundaryRows, decodeRows, encodeBoundaryRows, encodeRows, rowSchema, rowShape } from "#codec.ts"
 export type { CompiledSchema, SchemaId } from "#compile.ts"
 export { Schema } from "#compile.ts"
 export type {
-	ApplyExpected,
-	ApplyOptions,
 	ApplyOutcome,
 	CoreWitness,
 	DbInspection,
+	JudgeOutcome,
 	PreparedQuery,
 	QueryReader,
 	Snapshot,
-	StorageInspection
+	StorageInspection,
+	WriteExpected,
+	WriteOptions
 } from "#db.ts"
 export { Db } from "#db.ts"
 export {
+	AuthoringDiagnostic,
 	AuthoringError,
 	NativeLoadError,
 	NativeOperationError,
@@ -61,7 +56,6 @@ export type {
 	Arity,
 	Face,
 	FaceArityMismatch,
-	FaceData,
 	FaceFields,
 	FaceOwner,
 	FaceShapeMismatch,
@@ -94,14 +88,32 @@ export type {
 	U64Field,
 	UuidField
 } from "#fields.ts"
-export { bool, bytes, f64, i64, interval, span, str, u64, uuid } from "#fields.ts"
+export { bool, bytes, f64, i64, interval, str, u64, uuid } from "#fields.ts"
 export type { Same, SameLen } from "#judgment.ts"
 export type { ClassesOf, ClassWall, LawfulStatements, RelationClasses, SchemaClasses } from "#law.ts"
-export type { Violation, ViolationFact } from "#native.ts"
+export type {
+	AtomIr,
+	AtomSourceIr,
+	CmpOpIr,
+	ComparisonIr,
+	ConditionTreeIr,
+	FindTermIr,
+	HeadTermIr,
+	InteriorIr,
+	QueryIr,
+	RecIr,
+	RuleIr,
+	ScalarExprIr,
+	TermIr,
+	Violation,
+	ViolationFact
+} from "#native.ts"
 export type { FindColumn } from "#query/atom.ts"
 export { ALLEN } from "#query/atom.ts"
 export type { AnyComputeExpr, ComputeExpr, ComputeValue, QueryNode } from "#query/compute.ts"
 export { Compute } from "#query/compute.ts"
+export type { DescriptionParameter, DescriptionRow, DescriptionTable, QueryDescription } from "#query/description.ts"
+export { describeQuery, queryFromDescription } from "#query/description.ts"
 export type { Agg, RowOfFind } from "#query/find.ts"
 export type {
 	AnyQuery,
@@ -136,16 +148,11 @@ export type {
 export { v } from "#query/scope.ts"
 export type {
 	AnyRelation,
-	AnySelected,
 	Fact,
 	FieldsShape,
 	Relation,
-	RelationData,
 	RelationField,
-	RelationFields,
-	Selected,
-	SelectionBinding,
-	SelectionInput
+	RelationFields
 } from "#relation.ts"
 export { relation } from "#relation.ts"
 export type { CompleteResult } from "#result.ts"
@@ -169,6 +176,8 @@ export type {
 export { Scalar } from "#scalar.ts"
 export type { AnySchema, Schema as SchemaDeclaration, SchemaRelation, SchemaRelations } from "#schema.ts"
 export { schema } from "#schema.ts"
+export type { AnySelected, FieldsOf, Selected, SelectionBinding, SelectionInput } from "#selection.ts"
+export { select } from "#selection.ts"
 export type { Key, QueryTemplate, Rel } from "#shape.ts"
 export type {
 	CapacityBoundSpec,
@@ -185,14 +194,11 @@ export type {
 	ValueTypeSpec
 } from "#spec.ts"
 export type {
-	CapacityData,
 	CapacityStatement,
-	ContainedStatement,
-	ContainmentData,
-	KeyData,
+	ContainmentStatement,
 	KeyStatement,
-	Statement,
-	StatementData
+	MirrorsStatement,
+	Statement
 } from "#statements.ts"
 export { capacity, contained, key, mirrors, renderStatement } from "#statements.ts"
 export { Uuid } from "#uuid.ts"

package/src/internal/log.ts

@@ -21,6 +21,7 @@ export {
 	nativeBindingIsLoaded
 } from "#native.ts"
 export type { CompleteResult } from "#result.ts"
+export { factCellsOf } from "#rows.ts"
 export type { NativeRuntimeOptions, RepositoryLock } from "#runtime.ts"
 export {
 	finalizeClose,
@@ -44,3 +45,4 @@ export type {
 	RuntimeHandle
 } from "#runtime-native.ts"
 export { runtimeNative } from "#runtime-native.ts"
+export { schemasAgree } from "#schema.ts"

package/src/law.ts

@@ -58,7 +58,7 @@ import { AuthoringError } from "#errors.ts"
 
 import type { AnyClosed } from "#closed.ts"
 import { isClosedMember, sealedFieldsOf } from "#closed.ts"
-import type { FaceData } from "#face.ts"
+import type { AnyFace } from "#face.ts"
 import type { Same } from "#judgment.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
 import type { SchemaRelation, SchemaRelations } from "#schema.ts"
@@ -104,9 +104,9 @@ type ZipCoords<
 		: Acc
 	: Acc
 
-type StatementPairs<St extends Statement> = St["data"] extends {
-	readonly source: infer S extends FaceData
-	readonly target: infer T extends FaceData
+type StatementPairs<St extends Statement> = St extends {
+	readonly source: infer S extends AnyFace
+	readonly target: infer T extends AnyFace
 }
 	? string extends S["owner"]["name"]
 		? []
@@ -208,7 +208,7 @@ type DeclaredKeysOf<Stmts extends readonly Statement[], Acc extends readonly Key
 	infer H extends Statement,
 	...infer T extends readonly Statement[]
 ]
-	? H["data"] extends {
+	? H extends {
 			readonly kind: "key"
 			readonly owner: infer O extends AnyRelation
 			readonly projection: infer P extends readonly string[]
@@ -295,8 +295,8 @@ type DecidableRoster<Stmts extends readonly Statement[]> = [true] extends [IsMul
 		: [Stmts] extends [readonly [infer H extends Statement, ...infer T extends readonly Statement[]]]
 			? [true] extends [IsMulti<H>]
 				? false
-				: "key" extends H["data"]["kind"]
-					? [DecidableKeyData<H["data"]>] extends [true]
+				: "key" extends H["kind"]
+					? [DecidableKeyData<H>] extends [true]
 						? DecidableRoster<T>
 						: false
 					: DecidableRoster<T>
@@ -322,7 +322,7 @@ type DeclaredKeyMatch<N extends string, PU extends string, Keys extends readonly
 		: DeclaredKeyMatch<N, PU, T>
 	: TargetKeyWall<N, PU>
 
-type JudgeTargetFace<F extends FaceData, Keys extends readonly KeyEntry[]> = string extends F["owner"]["name"]
+type JudgeTargetFace<F extends AnyFace, Keys extends readonly KeyEntry[]> = string extends F["owner"]["name"]
 	? true
 	: string extends F["projection"][number]
 		? true
@@ -334,9 +334,9 @@ type JudgeTargetFace<F extends FaceData, Keys extends readonly KeyEntry[]> = str
 				? DeclaredKeyMatch<F["owner"]["name"], F["projection"][number], Keys>
 				: true
 
-type JudgeStatement<St extends Statement, Keys extends readonly KeyEntry[]> = St["data"] extends {
-	readonly source: FaceData
-	readonly target: infer Tg extends FaceData
+type JudgeStatement<St extends Statement, Keys extends readonly KeyEntry[]> = St extends {
+	readonly source: AnyFace
+	readonly target: infer Tg extends AnyFace
 }
 	? JudgeTargetFace<Tg, Keys>
 	: true
@@ -452,8 +452,8 @@ function makeUnionFind(): UnionFind {
 	}
 }
 
-function statementFaces(statement: Statement): readonly [FaceData, FaceData] | undefined {
-	const data = statement.data
+function statementFaces(statement: Statement): readonly [AnyFace, AnyFace] | undefined {
+	const data = statement
 	if (data.kind === "key") {
 		return undefined
 	}

package/src/lower.ts

@@ -15,10 +15,10 @@ import { AuthoringError } from "#errors.ts"
 
 import type { AnyClosed } from "#closed.ts"
 import { isClosedMember } from "#closed.ts"
-import type { FaceData } from "#face.ts"
-import type { AnyField } from "#fields.ts"
+import type { AnyFace } from "#face.ts"
+import { type AnyField, literalOf } from "#fields.ts"
 import type { RelationClasses } from "#law.ts"
-import type { AnyRelation } from "#relation.ts"
+import { type AnyRelation, relationFields } from "#relation.ts"
 import type { AnySchema } from "#schema.ts"
 import type {
 	FieldSpec,
@@ -60,7 +60,7 @@ function lowerField(name: string, field: AnyField, newtype: string | undefined):
 	}
 }
 
-function lowerFace(face: FaceData): SideSpec {
+function lowerFace(face: AnyFace): SideSpec {
 	return {
 		relation: face.owner.name,
 		projection: [...face.projection],
@@ -71,7 +71,7 @@ function lowerFace(face: FaceData): SideSpec {
 }
 
 function lowerStatement(statement: Statement): StatementSpec {
-	const data = statement.data
+	const data = statement
 	switch (data.kind) {
 		case "key":
 			return { kind: "fd", relation: data.owner.name, projection: [...data.projection] }
@@ -101,18 +101,21 @@ function lowerStatement(statement: Statement): StatementSpec {
 }
 
 function lowerRelation(relation: AnyRelation, classes: RelationClasses): RelationSpec {
-	const fields: FieldSpec[] = relation.data.fields.map(function lowerDeclared(declared) {
+	const fields: FieldSpec[] = relationFields(relation).map(function lowerDeclared(declared) {
 		return lowerField(declared.name, declared.field, classes[declared.name])
 	})
 	return { name: relation.name, fields, closed: undefined }
 }
 
 function lowerClosed(member: AnyClosed, classes: RelationClasses): RelationSpec {
-	const fields: FieldSpec[] = member.data.columns.map(function lowerColumn(column) {
-		return lowerField(column.name, column.field, classes[column.name])
+	const fields: FieldSpec[] = Object.entries(member.columns).map(function lowerColumn([name, field]) {
+		return lowerField(name, field, classes[name])
 	})
-	const rows = member.data.rows.map(function lowerRow(row) {
-		return { handle: row.handle, values: row.values }
+	const rows = member.handles.map(function lowerRow(handle) {
+		return {
+			handle,
+			values: Object.entries(member.columns).map(([name, field]) => literalOf(field, member.axioms[handle]?.[name]))
+		}
 	})
 	const newtype = classes.id
 	if (newtype === undefined) {