@bjornpagen/bumbledb 1.3.1 → 2.0.0

package/src/engine.ts

@@ -0,0 +1,14 @@
+/**
+ * The embedded engine: one `Db` over a local LMDB directory, for single-process use, tests and
+ * benches. Applications that want the durable log use `Database` from the package root.
+ */
+export type {
+	ApplyOutcome,
+	DbInspection,
+	JudgeOutcome,
+	PreparedQuery,
+	QueryReader,
+	Snapshot,
+	Witness
+} from "./db.ts"
+export { Db } from "./db.ts"

package/src/errors.ts

@@ -1,13 +1,11 @@
-import { Data, Schema } from "effect"
-
 /**
- * Pure authoring failures, SDK-invariant defects and internal native-boundary
- * diagnostics. AST misuse can throw synchronously without I/O. Runtime
- * adapters translate operational failures into the public `DbError` class
- * in `#runtime-errors.ts`; contradictions in SDK/native state remain defects.
+ * The SDK's errors. Authoring refusals throw synchronously while a schema, query or value is
+ * built; everything that runs as an Effect fails with `DbError { operation, reason }`; a native
+ * close that does not drain cleanly is a `CloseFailure` defect.
  */
+import { Schema } from "effect"
 
-/** A pure schema, query, parameter, or value-authoring refusal. */
+/** Where an authoring refusal points and what was expected there. */
 export const AuthoringDiagnostic = Schema.Struct({
 	code: Schema.Literals([
 		"InvalidValue",
@@ -22,40 +20,121 @@ export const AuthoringDiagnostic = Schema.Struct({
 })
 export type AuthoringDiagnostic = typeof AuthoringDiagnostic.Type
 
-export class AuthoringError extends Data.TaggedError("AuthoringError")<{
-	readonly message: string
-	readonly diagnostic?: AuthoringDiagnostic
-}> {}
-
-/** A contradiction in an SDK/native result, not an application refusal. */
-export class SdkInvariantError extends Data.TaggedError("SdkInvariantError")<{
-	readonly message: string
-}> {}
-
-export class NativeLoadError extends Data.TaggedError("NativeLoadError")<{
-	readonly package: string
-	readonly operation: "resolve" | "load"
-	readonly message: string
-	readonly cause: unknown
-}> {}
-
-/** A native bridge call's contextual failure; the exact thrown value is retained. */
-export class NativeOperationError extends Data.TaggedError("NativeOperationError")<{
-	readonly operation: string
-	readonly cause: unknown
-}> {
+/** A schema, query, parameter or value refused while it is being authored. */
+export class AuthoringError extends Schema.TaggedError<AuthoringError>()("AuthoringError", {
+	message: Schema.String,
+	diagnostic: Schema.optional(AuthoringDiagnostic)
+}) {}
+
+/** The native addon for this host could not be loaded. */
+export class NativeLoadError extends Schema.TaggedError<NativeLoadError>()("NativeLoadError", {
+	target: Schema.String,
+	message: Schema.String,
+	cause: Schema.Unknown
+}) {}
+
+const PlainReason = Schema.Struct({
+	_tag: Schema.Literals([
+		"RuntimeAlreadyLive",
+		"ForeignRuntime",
+		"ClosedHandle",
+		"HandleBusy",
+		"SpentHandle",
+		"QueueFull",
+		"Internal",
+		"DirectoryBusy",
+		"WriterBusy",
+		"InvalidPath",
+		"Cancelled",
+		"OutOfMemory"
+	])
+})
+const InvalidArgument = Schema.Struct({
+	_tag: Schema.Literal("InvalidArgument"),
+	detail: Schema.optional(
+		Schema.Struct({
+			message: Schema.String,
+			diagnostic: Schema.optional(AuthoringDiagnostic)
+		})
+	)
+})
+const InvalidValue = Schema.Struct({ _tag: Schema.Literal("InvalidValue"), message: Schema.String })
+const Io = Schema.Struct({ _tag: Schema.Literal("Io"), kind: Schema.String, osCode: Schema.optional(Schema.Number) })
+const ResourceLimit = Schema.Struct({
+	_tag: Schema.Literal("ResourceLimit"),
+	dimension: Schema.String,
+	used: Schema.BigInt,
+	requested: Schema.BigInt,
+	limit: Schema.BigInt
+})
+/** An engine refusal: the engine error's kind and message. */
+const Engine = Schema.Struct({ _tag: Schema.Literal("Engine"), kind: Schema.String, message: Schema.String })
+const Malformed = Schema.Struct({ _tag: Schema.Literal("Malformed"), path: Schema.String, message: Schema.String })
+
+/** Why an operation failed: the addon's `RuntimeError`, plus authoring detail on `InvalidArgument`. */
+export const DbReason = Schema.Union([PlainReason, InvalidArgument, InvalidValue, Io, ResourceLimit, Engine, Malformed])
+export type DbReason = typeof DbReason.Type
+
+/** The one runtime error: which operation failed, and why. */
+export class DbError extends Schema.TaggedError<DbError>()("DbError", {
+	operation: Schema.String,
+	reason: DbReason
+}) {
+	get code() {
+		return this.reason._tag
+	}
 	override get message(): string {
-		const cause = this.cause
+		return `${this.operation}: ${this.code}`
+	}
+}
+
+const decodeReason = Schema.decodeUnknownOption(DbReason)
+
+/** Reads a native refusal (or any thrown value) as a `DbError` for `operation`. */
+export function dbError(operation: string, cause: unknown): DbError {
+	if (cause instanceof DbError) return cause
+	if (cause instanceof AuthoringError) return argumentError(operation, cause)
+	const decoded = decodeReason(cause)
+	return new DbError({ operation, reason: decoded._tag === "Some" ? decoded.value : { _tag: "Internal" } })
+}
+
+/** An input refusal, keeping an authoring error's message and diagnostic. */
+export function argumentError(operation: string, cause: unknown): DbError {
+	if (cause instanceof DbError) return cause
+	if (cause instanceof AuthoringError) {
 		const detail =
-			typeof cause === "object" && cause !== null && "message" in cause && typeof cause.message === "string"
-				? cause.message
-				: String(cause)
-		return `${this.operation}: ${detail}`
+			cause.diagnostic === undefined
+				? { message: cause.message }
+				: { message: cause.message, diagnostic: cause.diagnostic }
+		return new DbError({ operation, reason: { _tag: "InvalidArgument", detail } })
 	}
+	return new DbError({ operation, reason: { _tag: "InvalidArgument" } })
 }
 
-export class NativeReportedError extends Data.TaggedError("NativeReportedError")<{
-	readonly kind: string
-	readonly message: string
-	readonly cause: unknown
-}> {}
+/** A contradiction between the SDK and the addon: a bug, reported as `Internal`. */
+export function internalError(operation: string): DbError {
+	return new DbError({ operation, reason: { _tag: "Internal" } })
+}
+
+const Outstanding = Schema.Struct({
+	phase: Schema.Literals(["Open", "Closing", "Closed"]),
+	queued: Schema.BigInt,
+	active: Schema.BigInt,
+	retained: Schema.BigInt,
+	owners: Schema.BigInt,
+	databases: Schema.BigInt,
+	natives: Schema.BigInt
+})
+export type OutstandingWork = typeof Outstanding.Type
+const Close = Schema.Union([
+	Schema.Struct({ _tag: Schema.Literal("Closed") }),
+	Schema.Struct({ _tag: Schema.Literal("Incomplete"), outstanding: Outstanding }),
+	Schema.Struct({ _tag: Schema.Literal("Failed") })
+])
+export type CloseReport = typeof Close.Type
+
+/** A native resource that did not drain cleanly when its scope closed. */
+export class CloseFailure extends Schema.TaggedError<CloseFailure>()("CloseFailure", {
+	operation: Schema.String,
+	report: Close
+}) {}

package/src/face.ts

@@ -1,12 +1,12 @@
-import type { AnyClosed } from "#closed.ts"
-import { memberDescriptor, sealedFieldOf } from "#closed.ts"
-import { AuthoringError } from "#errors.ts"
-import { type AnyField, assertDeclarationRecord, type SignatureOf } from "#fields.ts"
-import type { Same } from "#judgment.ts"
-import type { AnyRelation, FieldsShape } from "#relation.ts"
-import { type AnySelected, type FieldsOf, type SelectionBinding, selectionBindings } from "#selection.ts"
-import { renderLiteralSet } from "#spec.ts"
-import { arrayValue, recordValue } from "#values.ts"
+import type { AnyClosed } from "./closed.ts"
+import { memberDescriptor, sealedFieldOf } from "./closed.ts"
+import { AuthoringError } from "./errors.ts"
+import { type AnyField, assertDeclarationRecord, type SignatureOf } from "./fields.ts"
+import type { Same } from "./judgment.ts"
+import type { AnyRelation, FieldsShape } from "./relation.ts"
+import { type AnySelected, type FieldsOf, type SelectionBinding, selectionBindings } from "./selection.ts"
+import { renderLiteralSet } from "./spec.ts"
+import { arrayValue, recordValue } from "./values.ts"
 
 const emptySelection: readonly SelectionBinding[] = Object.freeze([])
 

package/src/fields.ts

@@ -1,8 +1,8 @@
 import { regex } from "arkregex"
-import { AuthoringError } from "#errors.ts"
-import type { LiteralSpec } from "#spec.ts"
-import type { Uuid } from "#uuid.ts"
-import { arrayValue, fieldValue, recordValue, taggedValueOf, U64_MAX } from "#values.ts"
+import { AuthoringError } from "./errors.ts"
+import type { LiteralSpec } from "./spec.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]*)$")
 
@@ -70,8 +70,7 @@ interface F64Field {
 /**
  * The application-owned 128-bit identity scalar: sixteen
  * exact bytes, spelled as the canonical hyphenated UUID {@link Uuid}
- * host value. There is no `fresh` mark anywhere: the database issues no
- * identity, and key laws are declared statements.
+ * host value. Key laws are declared statements.
  */
 interface UuidField {
 	readonly kind: "uuid"
@@ -335,7 +334,7 @@ const i64: I64Field = Object.freeze({ kind: "i64" })
 /** Binary64. The native value boundary canonicalizes NaN and signed zero. */
 const f64: F64Field = Object.freeze({ kind: "f64" })
 
-/** The application-owned 128-bit identity scalar; no fresh mark exists. */
+/** The application-owned 128-bit identity scalar. */
 const uuid: UuidField = Object.freeze({ kind: "uuid" })
 
 const bool: BoolField = Object.freeze({ kind: "bool" })

package/src/index.ts

@@ -1,12 +1,10 @@
 /**
- * @bjornpagen/bumbledb — the Effect-native TypeScript SDK for the
- * bumbledb embedded relational engine. Pure
- * schema/query/scalar construction is synchronous metadata; all work is
- * lazy, scoped and bounded on the one native runtime. No Promise, sync,
- * or disposal twin. The raw native bridge is not exported from this barrel.
+ * Typed schemas and queries, validated by the engine as they are defined, and the durable
+ * `Database` over an object store. Every database operation is a lazy, scoped Effect on the one
+ * native runtime; the embedded `Db` lives in `./engine`.
  */
 
-export { alternatives } from "#alternatives.ts"
+export { alternatives } from "./alternatives.ts"
 export type {
 	BoundsOnTarget,
 	CapacityWeight,
@@ -15,19 +13,19 @@ export type {
 	FieldRef,
 	UnitDimensionBan,
 	WeightOnSource
-} from "#capacity.ts"
-export { duration, ref, weigh, within } from "#capacity.ts"
-export type { ChangeCounts, ChangeDraft, ChangeRecord } from "#changes.ts"
-export { ChangeSet } from "#changes.ts"
+} from "./capacity.ts"
+export { duration, ref, weigh, within } from "./capacity.ts"
+export type { ChangeCounts, ChangeDraft, ChangeRecord } from "./changes.ts"
+export { ChangeSet } from "./changes.ts"
 export type {
 	AnyClosed,
 	AxiomRow,
 	Axioms,
 	Closed,
 	PayloadField
-} from "#closed.ts"
-export { closed, closedId } from "#closed.ts"
-export type { RowShape } from "#codec.ts"
+} from "./closed.ts"
+export { closed, closedId } from "./closed.ts"
+export type { RowShape } from "./codec.ts"
 export {
 	decodeBoundaryField,
 	decodeBoundaryRows,
@@ -38,30 +36,48 @@ export {
 	fieldSchema,
 	rowSchema,
 	rowShape
-} from "#codec.ts"
-export type { CompiledSchema, SchemaId } from "#compile.ts"
-export { Schema } from "#compile.ts"
+} from "./codec.ts"
+export type { SchemaId } from "./compile.ts"
 export type {
-	ApplyOutcome,
-	CoreWitness,
-	DbInspection,
-	JudgeOutcome,
-	PreparedQuery,
-	QueryReader,
-	Snapshot,
-	StorageInspection,
-	WriteExpected,
-	WriteOptions
-} from "#db.ts"
-export { Db } from "#db.ts"
+	Consistency,
+	DatabaseOptions,
+	DatabasePool,
+	DatabaseReader,
+	PoolOptions,
+	SubmitOptions,
+	SubmitOutcome,
+	Tuning
+} from "./database/database.ts"
+export { Database, RequestId } from "./database/database.ts"
+export { FsStore } from "./database/fs.ts"
+export type {
+	Body,
+	Bucket,
+	ExecutorOptions,
+	IoRequest,
+	IoResponse,
+	IoResult,
+	Millis,
+	ObjectStore,
+	Reply,
+	Target
+} from "./database/io.ts"
+export type { Fault, MemStoreOptions } from "./database/mem.ts"
+export { MemStore } from "./database/mem.ts"
+export type { AnyMigration, Migrations, Populate } from "./database/migration.ts"
+export { Migration } from "./database/migration.ts"
+export type { S3Sender, S3StoreOptions } from "./database/s3.ts"
+export { S3Store } from "./database/s3.ts"
+export type { PreparedQuery, QueryReader } from "./db.ts"
+export type { CloseReport, OutstandingWork } from "./errors.ts"
 export {
 	AuthoringDiagnostic,
 	AuthoringError,
-	NativeLoadError,
-	NativeOperationError,
-	NativeReportedError,
-	SdkInvariantError
-} from "#errors.ts"
+	CloseFailure,
+	DbError,
+	dbError,
+	NativeLoadError
+} from "./errors.ts"
 export type {
 	AnyFace,
 	Arity,
@@ -76,8 +92,8 @@ export type {
 	ProjectedShape,
 	SameArity,
 	SameShapes
-} from "#face.ts"
-export { on } from "#face.ts"
+} from "./face.ts"
+export { on } from "./face.ts"
 export type {
 	AnyClosedIdField,
 	AnyClosedRoster,
@@ -98,40 +114,26 @@ export type {
 	StrField,
 	U64Field,
 	UuidField
-} 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 {
-	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"
+} 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 {
-	DescriptionHead,
-	DescriptionParameter,
-	DescriptionRow,
-	DescriptionTable,
-	QueryDescription
-} from "#query/description.ts"
-export { describeQuery, queryFromDescription } from "#query/description.ts"
-export type { Agg, HeadRecordOf, RowOfFind } from "#query/find.ts"
+	EvidenceOut,
+	FactOut,
+	HeadOut,
+	MigrationOut,
+	OutcomeOut,
+	ReceiptOut,
+	RefusalOut,
+	SettledOut,
+	ViolationOut as Violation
+} from "./native/binding.d.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 { Agg, HeadRecordOf, RowOfFind } from "./query/find.ts"
 export type {
 	AnyQuery,
 	AnyRuleValue,
@@ -148,8 +150,8 @@ export type {
 	RecRuleScope,
 	RuleValue,
 	TermOps
-} from "#query/lower.ts"
-export { lowerQuery, query } from "#query/lower.ts"
+} from "./query/lower.ts"
+export { lowerQuery, query } from "./query/lower.ts"
 export type {
 	ClassedField,
 	Flatten,
@@ -162,9 +164,9 @@ export type {
 	SetParam,
 	Var,
 	VarsOf
-} from "#query/scope.ts"
-export { v } from "#query/scope.ts"
-export type { IntervalVar, SegmentOp, Segments } from "#query/segments.ts"
+} from "./query/scope.ts"
+export { v } from "./query/scope.ts"
+export type { IntervalVar, SegmentOp, Segments } from "./query/segments.ts"
 export type {
 	AnyRelation,
 	Fact,
@@ -172,15 +174,13 @@ export type {
 	Relation,
 	RelationField,
 	RelationFields
-} from "#relation.ts"
-export { relation } from "#relation.ts"
-export type { CompleteResult } from "#result.ts"
-export type { CellValue } from "#rows.ts"
-export { cellOf, factOfCells, flatRowsOf, keyCellsOf } from "#rows.ts"
-export type { NativeRuntimeOptions } from "#runtime.ts"
-export { NativeRuntime } from "#runtime.ts"
-export type { CloseReport, OutstandingWork } from "#runtime-errors.ts"
-export { CloseFailure, DbError, dbError, runtimeErrorCodes } from "#runtime-errors.ts"
+} from "./relation.ts"
+export { relation } from "./relation.ts"
+export type { CompleteResult } from "./result.ts"
+export type { CellValue } from "./rows.ts"
+export { cellOf, factOfCells, flatRowsOf, keyCellsOf } from "./rows.ts"
+export type { BumbleOptions } from "./runtime.ts"
+export { Bumble } from "./runtime.ts"
 export type {
 	IntervalKind,
 	NumericCast,
@@ -191,32 +191,19 @@ export type {
 	ScalarNode,
 	ScalarResultKind,
 	ScalarValue
-} 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,
-	CapacityWindowSpec,
-	FieldSpec,
-	LiteralSetSpec,
-	LiteralSpec,
-	RelationSpec,
-	RowSpec,
-	SchemaSpec,
-	SideSpec,
-	StatementSpec,
-	ValueSpec,
-	ValueTypeSpec
-} from "#spec.ts"
+} from "./scalar.ts"
+export type { AnySchema, Schema, 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, CapacityWindowSpec, LiteralSetSpec, LiteralSpec, ValueSpec } from "./spec.ts"
 export type {
 	CapacityStatement,
 	ContainmentStatement,
 	KeyStatement,
 	MirrorsStatement,
 	Statement
-} from "#statements.ts"
-export { capacity, contained, key, mirrors, renderStatement } from "#statements.ts"
-export { Uuid } from "#uuid.ts"
+} from "./statements.ts"
+export { capacity, contained, key, mirrors, renderStatement } from "./statements.ts"
+export { Uuid } from "./uuid.ts"

package/src/judgment.ts

@@ -3,7 +3,7 @@
  *
  * {@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,
+ * on tuple lengths — zero equals zero, n + 1 recurses on n,
  * everything else is refused. An open array carries no Nat (its length is
  * `number`), so it proves nothing.
  */

package/src/law.ts

@@ -1,68 +1,19 @@
-import { AuthoringError } from "#errors.ts"
+import { AuthoringError } from "./errors.ts"
 /**
- * The law-typing engine (owner ruling 2026-07-18, "option 2, zero debate"):
- * THE LAWS TYPE THE COLUMNS. Domains are declared nowhere — `schema`
- * computes every field's domain FROM the statement list, at BOTH the type
- * level (this module's type machinery, reading the statements tuple type)
- * and at runtime (a plain union-find over the same pairs), and the two
- * tiers are the same computation by construction.
- *
- * The three class laws (ratified; implemented exactly):
- *
- * 1. GENERATORS — a closed relation's synthetic id is a generator named
- * `"Kind.id"` (the vocabulary mints its own row ids). Ordinary relations
- * have no generator: the database issues no identity (`fresh` is deleted),
- * and identity fields are ordinary application-owned values.
- * 2. GENERATOR-LESS classes are named by their least member coordinate
- * in relation-declaration × field-declaration order (readable off the
- * relation record and each member's frozen field list at the VALUE
- * tier — deterministic, pinned forever; the wire reads only this
- * tier). At the TYPE tier the same class is carried as its
- * member-coordinate SET (see {@link ClassOfCoord}): TypeScript's
- * union member order is not observably deterministic, so a type-level
- * least-member pick would drift between compilations — the set is the
- * canonical deterministic spelling, the runtime name is always a
- * member of it, and the join judgment is identical at both tiers.
- * 3. BARE — a field in no law has NO class and pairs only with bare in
- * queries (the deliberate sum-domain pointer stays legal).
- *
- * THE WALL: a class containing more than one generator is a contradiction
- * (two mints cannot share a carrier) — a schema-level COMPILE error (the
- * named, self-locating {@link ClassWall}: which generator coordinates
- * collided, through which paired slots) with a construction-time runtime
- * twin (`computeClasses` throws with the same content, naming the exact
- * statement). The TARGET-KEY WALL ({@link TargetKeyWall},
- * 60-containment-parity) rides the same constraint seam: a containment/
- * mirrors/capacity target projection that resolves no key of its relation
- * is the same kind of schema-level compile error, with `schema`'s
- * `verifyTargetKeys` as its authoritative runtime twin.
- *
- * Every paired face of the statement tuple unions its positionwise field
- * slots: containment (ψ-selected targets included — a selection changes
- * pairing not at all), the `==` bijection, and capacity source/target pairs.
- * `key` statements pair nothing (an FD constrains one relation's own
- * rows; it identifies no carriers).
- *
- * The type tier reads pairs off the statement types' exact face data, so
- * spell the statement list INLINE in `schema` (the `const` type
- * parameter keeps the tuple precise). A widened `Statement[]` list
- * degrades the TYPE tier to generators-only (no pair is readable off a
- * widened type) — the runtime map stays complete and authoritative, and
- * the wire lowering reads only the runtime map. Every loop below is
- * tail-recursive with an accumulator, so the machinery rides TypeScript's
- * tail-recursion elimination for large schemas (~40 relations, ~200 slots,
- * ~123 statements); should a schema ever exceed the compiler's limits, tsc
- * fails LOUDLY with its own instantiation-depth error — the map is never
- * silently widened.
+ * The laws type the columns: `schema` computes each field's class from its statements at the type
+ * level and at runtime (a union-find over the same pairs). A closed id is a generator naming its
+ * class, a generator-less class is named by its least member coordinate, and a field in no law is
+ * bare. Two generators in one class, or a target projection that resolves no key, is a compile
+ * error with a runtime twin. Spell statements inline: a widened list degrades the type tier.
  */
 
-import type { AnyClosed } from "#closed.ts"
-import { isClosedMember, sealedFieldsOf } from "#closed.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"
-import { renderStatement, type Statement } from "#statements.ts"
+import type { AnyClosed } from "./closed.ts"
+import { isClosedMember, sealedFieldsOf } from "./closed.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"
+import { renderStatement, type Statement } from "./statements.ts"
 
 type RelationClasses = { readonly [field: string]: string | undefined }
 
@@ -277,16 +228,13 @@ type DecidableKeyData<D> = [D] extends [
  * widened owner, a widened or union projection each make the roster
  * UNKNOWABLE.
  *
- * Any failure is the tier's one forbidden verdict in waiting — a false
- * wall — so anything outside the whitelist degrades the WHOLE
- * {@link TargetKeyWall} to silent (the degradation law: best effort
+ * A wrong answer here would be a false wall, so anything outside the
+ * whitelist degrades the WHOLE {@link TargetKeyWall} to silent (best effort
  * degrades to silent, never to a wrong judgment), exactly as a widened
  * FACE already silences its own judgment; the value tier stays
- * authoritative. ONE recorded limit, pre-existing and outside this
- * detector's reach: a generic type parameter CONSTRAINED to a union of
- * tuples hangs tsc in the deferred-scan machinery before any verdict is
- * reached — a degenerate spelling no shipped surface writes, recorded
- * here as the tier's known boundary, not fixed.
+ * authoritative. Known limit: a generic type parameter CONSTRAINED to a
+ * union of tuples hangs tsc in the deferred-scan machinery; no shipped
+ * surface writes that spelling.
  */
 type DecidableRoster<Stmts extends readonly Statement[]> = [true] extends [IsMulti<Stmts>]
 	? false