@bjornpagen/bumbledb 1.0.1 → 1.2.0

package/src/runtime-native.ts

@@ -34,7 +34,7 @@ export interface RepositoryLockHandle {
 }
 
 /** Resource kinds installed in native worker tables. */
-export type NativeKind = "snapshot" | "result" | "cursor" | "draft" | "changes" | "repository-lock"
+export type NativeKind = "snapshot" | "prepared" | "result" | "cursor" | "draft" | "changes" | "repository-lock"
 
 /**
  * Checked capability into the native registry. JS tokens validate
@@ -96,28 +96,13 @@ export type LogTakeWire =
 			readonly digest: Uint8Array
 	  }
 
-export interface PolicyWire {
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
-	readonly rows: bigint
-	readonly workUnits: bigint
-	readonly timeoutMs: number
-}
-
 export interface OptionsWire {
-	readonly workers: number
-	readonly queueCapacity: number
-	readonly cleanupCapacity: number
-	readonly ownerCapacity: number
-	readonly nativeHandleCapacity: number
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
-	readonly chunkBytes: bigint
-	readonly cleanupTimeoutMs: number
+	readonly workers?: number | undefined
+	readonly queueCapacity?: number | undefined
+	readonly cleanupCapacity?: number | undefined
+	readonly ownerCapacity?: number | undefined
+	readonly nativeHandleCapacity?: number | undefined
+	readonly cleanupTimeoutMs?: number | undefined
 }
 
 export interface InspectionWire {
@@ -128,10 +113,6 @@ export interface InspectionWire {
 	readonly owners: bigint
 	readonly databases: bigint
 	readonly natives: bigint
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
 }
 
 export type CloseWire =
@@ -142,8 +123,8 @@ export type CloseWire =
 interface RuntimeNative {
 	runtimeErrorCodes(): readonly string[]
 	runtimeOpen(options: OptionsWire): RuntimeHandle
-	runtimeReady(runtime: RuntimeHandle, policy: PolicyWire, callback: () => void): OperationHandle
-	runtimeHash(runtime: RuntimeHandle, policy: PolicyWire, bytes: Uint8Array, callback: () => void): OperationHandle
+	runtimeReady(runtime: RuntimeHandle, callback: () => void): OperationHandle
+	runtimeHash(runtime: RuntimeHandle, bytes: Uint8Array, callback: () => void): OperationHandle
 	runtimeTake(operation: OperationHandle): Uint8Array | null
 	runtimeCancel(operation: OperationHandle, callback: (report: CloseWire) => void): void
 	runtimeClose(runtime: RuntimeHandle, callback: (report: CloseWire) => void): void
@@ -156,20 +137,14 @@ interface RuntimeNative {
 	 * Predelivery: no JS take; cursor stays on row1 so retry does not skip.
 	 */
 	runtimeArmPublicationCancel(runtime: RuntimeHandle): void
-	runtimeDirectoryAcquire(
-		runtime: RuntimeHandle,
-		policy: PolicyWire,
-		path: string,
-		callback: () => void
-	): OperationHandle
+	runtimeDirectoryAcquire(runtime: RuntimeHandle, path: string, callback: () => void): OperationHandle
 	runtimeDirectoryTake(operation: OperationHandle): DirectoryHandle
-	runtimeDirectoryBegin(owner: DirectoryHandle, policy: PolicyWire): OperationHandle
+	runtimeDirectoryBegin(owner: DirectoryHandle): OperationHandle
 	runtimeDirectoryCheck(operation: OperationHandle): void
 	runtimeDirectoryEnd(operation: OperationHandle): void
 	runtimeDirectoryClose(owner: DirectoryHandle, remove: boolean, callback: (report: CloseWire) => void): void
 	runtimeDirectoryDbOpen(
 		owner: DirectoryHandle,
-		policy: PolicyWire,
 		childName: string,
 		spec: SchemaSpec,
 		create: boolean,
@@ -178,12 +153,11 @@ interface RuntimeNative {
 	runtimeDbTake(operation: OperationHandle): ManagedDbOutcome
 	runtimeManagedDbClose(db: DbHandle, callback: (report: CloseWire) => void): void
 
-	// --- successor log grammar on the executor (charged hashing over
+	// --- successor log grammar on the executor (hashing over
 	// whole canonical change payloads; C06 through C09) ---
 	runtimeLogCommandSeal(
 		runtime: RuntimeHandle,
 		schema: LogSchemaHandle,
-		policy: PolicyWire,
 		metadata: LogCommandMetadata,
 		changes: Uint8Array,
 		result: Uint8Array | null,
@@ -193,14 +167,12 @@ interface RuntimeNative {
 	runtimeLogCommandParse(
 		runtime: RuntimeHandle,
 		schema: LogSchemaHandle,
-		policy: PolicyWire,
 		bytes: Uint8Array,
 		limits: LogLimits,
 		callback: () => void
 	): OperationHandle
 	runtimeLogDecisionDecode(
 		runtime: RuntimeHandle,
-		policy: PolicyWire,
 		bytes: Uint8Array,
 		parent: LogDecisionStamp | null,
 		limits: LogLimits,
@@ -208,12 +180,7 @@ interface RuntimeNative {
 	): OperationHandle
 	runtimeLogTake(operation: OperationHandle): LogTakeWire
 	/** L14 mint: `Runtime::mint_repository_lock` stamps `NativeKind::RepositoryLock` at take. */
-	logRepositoryLockAcquire(
-		runtime: RuntimeHandle,
-		policy: PolicyWire,
-		directory: string,
-		callback: () => void
-	): OperationHandle
+	logRepositoryLockAcquire(runtime: RuntimeHandle, directory: string, callback: () => void): OperationHandle
 	logRepositoryLockTake(operation: OperationHandle): RepositoryLockHandle
 	logRepositoryLockRelease(owner: RepositoryLockHandle, callback: (report: CloseWire) => void): void
 }

package/src/runtime.ts

@@ -1,43 +1,21 @@
 import { Context, Duration, Effect, Exit, Layer } from "effect"
 import type { CloseReport, OutstandingWork } from "#runtime-errors.ts"
 import { CloseFailure, DbError, dbError } from "#runtime-errors.ts"
-import type {
-	CloseWire,
-	OperationHandle,
-	OptionsWire,
-	PolicyWire,
-	RepositoryLockHandle,
-	RuntimeHandle
-} from "#runtime-native.ts"
+import type { CloseWire, OperationHandle, OptionsWire, RepositoryLockHandle, RuntimeHandle } from "#runtime-native.ts"
 import { runtimeNative } from "#runtime-native.ts"
 
-export interface ExecutionPolicy {
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
-	readonly rows: bigint
-	readonly workUnits: bigint
-	readonly timeout: Duration.Input
-}
-
 export interface NativeRuntimeOptions {
-	readonly workers: number
-	readonly queueCapacity: number
-	readonly cleanupCapacity: number
-	readonly ownerCapacity: number
-	readonly nativeHandleCapacity: number
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
-	readonly chunkBytes: bigint
-	readonly cleanupTimeout: Duration.Input
+	readonly workers?: number
+	readonly queueCapacity?: number
+	readonly cleanupCapacity?: number
+	readonly ownerCapacity?: number
+	readonly nativeHandleCapacity?: number
+	readonly cleanupTimeout?: Duration.Input
 }
 
 interface RuntimeService {
 	readonly close: () => Effect.Effect<CloseReport>
-	readonly inspect: (work: ExecutionPolicy) => Effect.Effect<OutstandingWork, DbError>
+	readonly inspect: () => Effect.Effect<OutstandingWork, DbError>
 }
 
 const owners = new WeakMap<RuntimeService, RuntimeHandle>()
@@ -51,43 +29,23 @@ function count(value: number, operation: string): number {
 	return value
 }
 
-function bytes(value: bigint, operation: string): bigint {
-	if (typeof value !== "bigint" || value < 0n || value > 0xffffffffffffffffn) throw invalid(operation)
-	return value
-}
-
 function millis(value: Duration.Input, operation: string): number {
 	const duration = Duration.toMillis(value)
 	if (!Number.isFinite(duration) || duration < 0 || duration > 0xffffffff) throw invalid(operation)
 	return Math.ceil(duration)
 }
 
-export function policyWire(work: ExecutionPolicy, operation: string): PolicyWire {
-	return {
-		inputBytes: bytes(work.inputBytes, operation),
-		workingBytes: bytes(work.workingBytes, operation),
-		scratchBytes: bytes(work.scratchBytes, operation),
-		resultBytes: bytes(work.resultBytes, operation),
-		rows: bytes(work.rows, operation),
-		workUnits: bytes(work.workUnits, operation),
-		timeoutMs: millis(work.timeout, operation)
-	}
-}
-
 function options(value: NativeRuntimeOptions): OptionsWire {
 	const operation = "NativeRuntime.acquire"
 	return {
-		workers: count(value.workers, operation),
-		queueCapacity: count(value.queueCapacity, operation),
-		cleanupCapacity: count(value.cleanupCapacity, operation),
-		ownerCapacity: count(value.ownerCapacity, operation),
-		nativeHandleCapacity: count(value.nativeHandleCapacity, operation),
-		inputBytes: bytes(value.inputBytes, operation),
-		workingBytes: bytes(value.workingBytes, operation),
-		scratchBytes: bytes(value.scratchBytes, operation),
-		resultBytes: bytes(value.resultBytes, operation),
-		chunkBytes: bytes(value.chunkBytes, operation),
-		cleanupTimeoutMs: count(millis(value.cleanupTimeout, operation), operation)
+		workers: value.workers === undefined ? undefined : count(value.workers, operation),
+		queueCapacity: value.queueCapacity === undefined ? undefined : count(value.queueCapacity, operation),
+		cleanupCapacity: value.cleanupCapacity === undefined ? undefined : count(value.cleanupCapacity, operation),
+		ownerCapacity: value.ownerCapacity === undefined ? undefined : count(value.ownerCapacity, operation),
+		nativeHandleCapacity:
+			value.nativeHandleCapacity === undefined ? undefined : count(value.nativeHandleCapacity, operation),
+		cleanupTimeoutMs:
+			value.cleanupTimeout === undefined ? undefined : count(millis(value.cleanupTimeout, operation), operation)
 	}
 }
 
@@ -169,14 +127,6 @@ function afterClose<A, E, R>(
 	return effect.pipe(Effect.onExit(() => Effect.die(new CloseFailure({ operation, report }))))
 }
 
-/** Independent caps intersect: a delivery request cannot enlarge `work.resultBytes`. */
-export function deliveryResultBytes(requested: bigint, work: ExecutionPolicy): bigint {
-	if (typeof requested !== "bigint" || requested < 0n) {
-		throw invalid("deliveryResultBytes")
-	}
-	return requested < work.resultBytes ? requested : work.resultBytes
-}
-
 function close(handle: RuntimeHandle): Effect.Effect<CloseReport> {
 	return drain("NativeRuntime.close", (callback) => runtimeNative.runtimeClose(handle, callback))
 }
@@ -257,54 +207,41 @@ const acquire = Effect.fn("NativeRuntime.acquire")(function* (configuration: Nat
 						const wire = options(configuration)
 						handle = runtimeNative.runtimeOpen(wire)
 						const owner = handle
-						const lease = runtimeNative.runtimeReady(
-							owner,
-							{
-								inputBytes: 0n,
-								workingBytes: 0n,
-								scratchBytes: 0n,
-								resultBytes: 0n,
-								rows: 0n,
-								workUnits: 1n,
-								timeoutMs: wire.cleanupTimeoutMs
-							},
-							() => {
-								if (signal.aborted) {
-									try {
-										runtimeNative.runtimeClose(owner, (report) => {
-											stash.report = closeReport("NativeRuntime.acquire.cancel", report)
-										})
-									} catch (cause) {
-										stash.report = { kind: "failed", error: failure("NativeRuntime.acquire.cancel", cause) }
-									}
-									return
-								}
+						const lease = runtimeNative.runtimeReady(owner, () => {
+							if (signal.aborted) {
 								try {
-									runtimeNative.runtimeTake(lease)
-									const service: RuntimeService = {
-										close: () => close(owner),
-										inspect: Effect.fn("NativeRuntime.inspect")(function* (work) {
-											yield* nativeOperation(
-												"NativeRuntime.inspect",
-												(callback) =>
-													runtimeNative.runtimeReady(owner, policyWire(work, "NativeRuntime.inspect"), callback),
-												() => undefined
-											)
-											return runtimeNative.runtimeInspect(owner)
-										})
-									}
-									owners.set(service, owner)
-									resume(Effect.succeed(service))
+									runtimeNative.runtimeClose(owner, (report) => {
+										stash.report = closeReport("NativeRuntime.acquire.cancel", report)
+									})
 								} catch (cause) {
-									const error = failure("NativeRuntime.acquire", cause)
-									resume(
-										close(owner).pipe(
-											Effect.flatMap((report) => afterClose("NativeRuntime.acquire", report, Effect.fail(error)))
+									stash.report = { kind: "failed", error: failure("NativeRuntime.acquire.cancel", cause) }
+								}
+								return
+							}
+							try {
+								runtimeNative.runtimeTake(lease)
+								const service: RuntimeService = {
+									close: () => close(owner),
+									inspect: Effect.fn("NativeRuntime.inspect")(function* () {
+										yield* nativeOperation(
+											"NativeRuntime.inspect",
+											(callback) => runtimeNative.runtimeReady(owner, callback),
+											() => undefined
 										)
-									)
+										return runtimeNative.runtimeInspect(owner)
+									})
 								}
+								owners.set(service, owner)
+								resume(Effect.succeed(service))
+							} catch (cause) {
+								const error = failure("NativeRuntime.acquire", cause)
+								resume(
+									close(owner).pipe(
+										Effect.flatMap((report) => afterClose("NativeRuntime.acquire", report, Effect.fail(error)))
+									)
+								)
 							}
-						)
+						})
 					} catch (cause) {
 						const error = failure("NativeRuntime.acquire", cause)
 						resume(
@@ -333,7 +270,7 @@ const acquire = Effect.fn("NativeRuntime.acquire")(function* (configuration: Nat
 export class NativeRuntime extends Context.Service<NativeRuntime, RuntimeService>()(
 	"@bjornpagen/bumbledb/NativeRuntime"
 ) {
-	static layer(options: NativeRuntimeOptions): Layer.Layer<NativeRuntime, DbError> {
+	static layer(options: NativeRuntimeOptions = {}): Layer.Layer<NativeRuntime, DbError> {
 		return Layer.effect(NativeRuntime, acquire(options))
 	}
 }
@@ -374,17 +311,12 @@ function joinLockRelease(operation: string, owner: RepositoryLockHandle): Effect
  */
 export const internalAcquireRepositoryLock = Effect.fn("internalAcquireRepositoryLock")(function* (
 	operation: string,
-	directory: string,
-	work: ExecutionPolicy
+	directory: string
 ) {
 	if (directory.length === 0) {
 		return yield* Effect.fail(invalid(operation))
 	}
 	const runtime = yield* runtimeHandle()
-	const wire = yield* Effect.try({
-		try: () => policyWire(work, operation),
-		catch: () => invalid(operation)
-	})
 	const closeOp = `${operation}.repositoryLock`
 	return yield* Effect.uninterruptibleMask((restore) =>
 		Effect.gen(function* () {
@@ -406,7 +338,7 @@ export const internalAcquireRepositoryLock = Effect.fn("internalAcquireRepositor
 			const owner = yield* restore(
 				nativeOperationWith(
 					operation,
-					(callback) => runtimeNative.logRepositoryLockAcquire(runtime, wire, directory, callback),
+					(callback) => runtimeNative.logRepositoryLockAcquire(runtime, directory, callback),
 					runtimeNative.logRepositoryLockTake,
 					(value) => value
 				)
@@ -421,7 +353,7 @@ export const internalAcquireRepositoryLock = Effect.fn("internalAcquireRepositor
 })
 
 /** Internal first executor consumer; not a replacement row codec or public hash API. */
-export const hashChunk = Effect.fn("bumbledb.hashChunk")(function* (input: Uint8Array, work: ExecutionPolicy) {
+export const hashChunk = Effect.fn("bumbledb.hashChunk")(function* (input: Uint8Array) {
 	const runtime = yield* NativeRuntime
 	const handle = owners.get(runtime)
 	if (handle === undefined) return yield* Effect.fail(invalid("hashChunk"))
@@ -429,7 +361,7 @@ export const hashChunk = Effect.fn("bumbledb.hashChunk")(function* (input: Uint8
 		"hashChunk",
 		(callback) => {
 			if (!(input instanceof Uint8Array) || !(input.buffer instanceof ArrayBuffer)) throw invalid("hashChunk")
-			return runtimeNative.runtimeHash(handle, policyWire(work, "hashChunk"), input, callback)
+			return runtimeNative.runtimeHash(handle, input, callback)
 		},
 		(value) => {
 			if (value === null) throw dbError("hashChunk", { _tag: "Internal" })

package/src/schema.ts

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util"
 import { AuthoringError, SdkInvariantError } from "#errors.ts"
 /**
  * `schema` — assembles relations and statements into a theory value (the
@@ -17,13 +18,15 @@ import { AuthoringError, SdkInvariantError } from "#errors.ts"
  */
 
 import type { AnyClosed } from "#closed.ts"
-import { isClosedMember, sealedFieldOf } from "#closed.ts"
-import type { FaceData } from "#face.ts"
+import { isClosedMember, memberDescriptor, membersAgree, sealedFieldOf } from "#closed.ts"
+import type { AnyFace } from "#face.ts"
 import { assertDeclarationOrderKey, assertDeclarationRecord, rosterOf } from "#fields.ts"
+import { descriptorCache, isImmutable } from "#immutable.ts"
 import { type ClassesOf, classesComplete, computeClasses, type LawfulStatements, type SchemaClasses } from "#law.ts"
 import type { AnyRelation } from "#relation.ts"
 import type { LiteralSetSpec, LiteralSpec } from "#spec.ts"
-import { isStatement, renderStatement, type Statement } from "#statements.ts"
+import { renderStatement, type Statement, statementDescriptor } from "#statements.ts"
+import { arrayValue, recordValue } from "#values.ts"
 
 interface ImpliedKeys {
 	readonly rendered: ReadonlySet<string>
@@ -54,7 +57,7 @@ function collectImplied(name: string, relations: SchemaRelations): ImpliedKeys {
 }
 
 function statementOwners(statement: Statement): readonly SchemaRelation[] {
-	const data = statement.data
+	const data = statement
 	if (data.kind === "key") {
 		return [data.owner]
 	}
@@ -69,9 +72,9 @@ function verifyMembership(name: string, relations: SchemaRelations, statement: S
 				message: `schema ${name}: relation ${owner.name} is not declared in this schema — ${rendered}`
 			})
 		}
-		if (member !== owner) {
+		if (!membersAgree(member, owner)) {
 			throw new AuthoringError({
-				message: `schema ${name}: statement references a different relation value named ${owner.name} than the one this schema declares — ${rendered}`
+				message: `schema ${name}: statement references a different relation declaration named ${owner.name} than the one this schema declares — ${rendered}`
 			})
 		}
 	}
@@ -86,7 +89,7 @@ function bindingLiterals(set: LiteralSetSpec): readonly LiteralSpec[] {
 
 function verifyBindingHandles(
 	name: string,
-	face: FaceData,
+	face: AnyFace,
 	binding: { readonly field: string; readonly set: LiteralSetSpec },
 	rendered: string
 ): void {
@@ -109,7 +112,7 @@ function verifyBindingHandles(
 }
 
 function verifyHandles(name: string, statement: Statement, rendered: string): void {
-	const data = statement.data
+	const data = statement
 	if (data.kind === "key") {
 		return
 	}
@@ -122,11 +125,11 @@ function verifyHandles(name: string, statement: Statement, rendered: string): vo
 
 function closedTargetOf(statements: readonly Statement[], owner: string, field: string): string | undefined {
 	for (const statement of statements) {
-		const data = statement.data
+		const data = statement
 		if (data.kind !== "containment" && data.kind !== "mirrors") {
 			continue
 		}
-		const pairs: Array<readonly [FaceData, FaceData]> = [[data.source, data.target]]
+		const pairs: Array<readonly [AnyFace, AnyFace]> = [[data.source, data.target]]
 		if (data.kind === "mirrors") {
 			pairs.push([data.target, data.source])
 		}
@@ -148,7 +151,7 @@ function closedTargetOf(statements: readonly Statement[], owner: string, field:
 
 function verifyClosedReferences(name: string, statements: readonly Statement[]): void {
 	for (const statement of statements) {
-		const data = statement.data
+		const data = statement
 		if (data.kind === "key") {
 			continue
 		}
@@ -164,7 +167,7 @@ function verifyClosedReferences(name: string, statements: readonly Statement[]):
 function verifyClosedReferenceBinding(
 	name: string,
 	statements: readonly Statement[],
-	face: FaceData,
+	face: AnyFace,
 	binding: { readonly field: string; readonly set: LiteralSetSpec },
 	rendered: string
 ): void {
@@ -213,7 +216,7 @@ function verifyTargetKeys(
 ): void {
 	const declared = new Map<string, Array<readonly string[]>>()
 	for (const statement of statements) {
-		const data = statement.data
+		const data = statement
 		if (data.kind !== "key") {
 			continue
 		}
@@ -225,7 +228,7 @@ function verifyTargetKeys(
 		}
 	}
 	for (const statement of statements) {
-		const data = statement.data
+		const data = statement
 		if (data.kind === "key") {
 			continue
 		}
@@ -251,7 +254,7 @@ function verifyTargetKeys(
  */
 function verifyTargetKeyFace(
 	name: string,
-	face: FaceData,
+	face: AnyFace,
 	implied: ReadonlyMap<string, ReadonlyArray<readonly string[]>>,
 	declared: ReadonlyMap<string, ReadonlyArray<readonly string[]>>,
 	rendered: string
@@ -310,25 +313,92 @@ interface Schema<Rels extends SchemaRelations, Classes extends SchemaClasses = S
 
 type AnySchema = Schema<SchemaRelations>
 
+/**
+ * Logical schema equivalence, including the ordered native ordinals and
+ * host decoding domains. Schema display names do not change the theory.
+ * A database/snapshot still has its own resource identity and lifetime.
+ */
+function schemasAgree(leftInput: AnySchema, rightInput: AnySchema): boolean {
+	const left = schemaDescriptor(leftInput)
+	const right = schemaDescriptor(rightInput)
+	if (left === right) return true
+	const cacheable = isImmutable(left) && isImmutable(right)
+	const cached = schemaComparisons.get(left)?.get(right)
+	if (cacheable && cached !== undefined) return cached
+	const names = Object.keys(left.relations)
+	const otherNames = Object.keys(right.relations)
+	const equal =
+		names.length === otherNames.length &&
+		names.every((name, index) => {
+			const member = right.relations[name]
+			return name === otherNames[index] && member !== undefined && membersAgree(left.relations[name], member)
+		}) &&
+		isDeepStrictEqual(left.statements, right.statements) &&
+		isDeepStrictEqual(left.classes, right.classes)
+	if (cacheable) {
+		let comparisons = schemaComparisons.get(left)
+		if (comparisons === undefined) {
+			comparisons = new WeakMap()
+			schemaComparisons.set(left, comparisons)
+		}
+		comparisons.set(right, equal)
+	}
+	return equal
+}
+
+const schemaComparisons = new WeakMap<AnySchema, WeakMap<AnySchema, boolean>>()
+
+function schemaDescriptor<S extends AnySchema>(input: S): S
+function schemaDescriptor(input: unknown): AnySchema
+function schemaDescriptor(input: unknown): AnySchema {
+	return checkedSchema(input)
+}
+
+const checkedSchema = descriptorCache((input): AnySchema => {
+	const raw = recordValue("schema", input, ["name", "relations", "statements", "classes"])
+	if (typeof raw.name !== "string") throw new AuthoringError({ message: "schema: expected a name" })
+	const relations = ownRelations(raw.name, raw.relations)
+	const statements = arrayValue("schema statements", raw.statements, (_, statement) => statementDescriptor(statement))
+	const result = schema(raw.name, relations, statements)
+	const classes = recordValue("schema classes", raw.classes, Object.keys(result.classes))
+	for (const [name, fields] of Object.entries(result.classes)) {
+		const supplied = recordValue(`schema classes.${name}`, classes[name], Object.keys(fields))
+		for (const [field, value] of Object.entries(fields)) {
+			if (supplied[field] !== value)
+				throw new AuthoringError({ message: `schema classes.${name}.${field}: incorrect class` })
+		}
+	}
+	return result
+})
+
 type EvaluatedClasses<C extends SchemaClasses> = C extends SchemaClasses
 	? { readonly [N in keyof C]: { readonly [F in keyof C[N]]: C[N][F] } }
 	: never
 
+function ownRelations<R extends SchemaRelations>(name: string, input: R): R
+function ownRelations(name: string, input: unknown): SchemaRelations
+function ownRelations(name: string, input: unknown): SchemaRelations {
+	if (typeof input !== "object" || input === null)
+		throw new AuthoringError({ message: `schema ${name}: expected relations` })
+	assertDeclarationRecord(`schema ${name} relations`, input)
+	return Object.freeze(
+		Object.fromEntries(Object.entries(input).map(([name, member]) => [name, memberDescriptor(member)]))
+	)
+}
+
 function schema<const Rels extends SchemaRelations, const Stmts extends readonly Statement[]>(
 	name: string,
 	relations: Rels,
 	statements: Stmts & LawfulStatements<Rels, Stmts>
 ): Schema<Rels, EvaluatedClasses<ClassesOf<Rels, Stmts>>> {
-	const implied = collectImplied(name, relations)
+	assertDeclarationOrderKey("schema", name)
+	const ownedRelations = ownRelations(name, relations)
+	const ownedStatements = arrayValue("schema statements", statements, (_, statement) => statementDescriptor(statement))
+	const implied = collectImplied(name, ownedRelations)
 	const seen = new Set<string>()
-	for (const statement of statements) {
-		if (!isStatement(statement)) {
-			throw new AuthoringError({
-				message: `schema ${name}: a statement is minted only by key/contained/mirrors/capacity — a structural literal skips the construction-time arity and roster walls`
-			})
-		}
+	for (const statement of ownedStatements) {
 		const rendered = renderStatement(statement)
-		verifyMembership(name, relations, statement, rendered)
+		verifyMembership(name, ownedRelations, statement, rendered)
 		if (implied.rendered.has(rendered)) {
 			throw new AuthoringError({
 				message: `schema ${name}: ${rendered} is redundant here (closedness already implies it) — and rejected as a duplicate`
@@ -340,14 +410,14 @@ function schema<const Rels extends SchemaRelations, const Stmts extends readonly
 		seen.add(rendered)
 		verifyHandles(name, statement, rendered)
 	}
-	verifyClosedReferences(name, statements)
-	verifyTargetKeys(name, statements, implied.roster)
-	const classes = computeClasses(name, relations, statements)
-	if (!classesComplete<EvaluatedClasses<ClassesOf<Rels, Stmts>>>(classes, relations)) {
+	verifyClosedReferences(name, ownedStatements)
+	verifyTargetKeys(name, ownedStatements, implied.roster)
+	const classes = computeClasses(name, ownedRelations, ownedStatements)
+	if (!classesComplete<EvaluatedClasses<ClassesOf<Rels, Stmts>>>(classes, ownedRelations)) {
 		throw new SdkInvariantError({ message: `schema ${name}: class-map construction incomplete` })
 	}
-	return Object.freeze({ name, relations, statements: Object.freeze([...statements]), classes })
+	return Object.freeze({ name, relations: ownedRelations, statements: Object.freeze(ownedStatements), classes })
 }
 
 export type { AnySchema, Schema, SchemaRelation, SchemaRelations }
-export { schema }
+export { schema, schemaDescriptor, schemasAgree }