@bjornpagen/bumbledb 1.3.0 → 2.0.0-rc.1

package/src/schema.ts

@@ -1,42 +1,24 @@
 import { isDeepStrictEqual } from "node:util"
-import { AuthoringError, SdkInvariantError } from "#errors.ts"
+import { isCompiledSchema, registerCompiled } from "./compile.ts"
+import { AuthoringError, internalError } from "./errors.ts"
 /**
- * `schema` — assembles relations and statements into a theory value (the
- * `Theory` analog; what `Db.create`/`Db.open` take). Construction-time
- * validation is the macro-EXPANSION-boundary analog: membership,
- * implied-key duplicates, duplicate statements, a belt-and-braces handle
- * re-verification — and the TARGET-KEY WALL ({@link verifyTargetKeys}),
- * the value tier of the two-tier containment law
- * (60-containment-parity): every containment/mirrors/capacity target
- * projection must set-match a key of its relation, judged HERE with the
- * engine's exact rule so `lower` never emits an engine-refused
- * containment. The type tier is `law.ts`'s `TargetKeyWall` (best effort,
- * statically known tuples); every OTHER semantic judgment (key-internal
- * legality, …) stays the engine's `SchemaError` at
- * `Db.create` — the engine is the final authority for every boundary,
- * this wall just makes the SDK agree with it first.
+ * `schema` assembles relations and statements into a schema value and has the engine compile it.
+ * The SDK checks only what the engine cannot see: that every statement names this schema's own
+ * relation values. Every other judgment is the engine's, reported as an `AuthoringError`.
  */
 
-import type { AnyClosed } from "#closed.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 { renderStatement, type Statement, statementDescriptor } from "#statements.ts"
-import { arrayValue, recordValue } from "#values.ts"
-
-interface ImpliedKeys {
-	readonly rendered: ReadonlySet<string>
-	readonly roster: ReadonlyMap<string, ReadonlyArray<readonly string[]>>
-}
-
-function collectImplied(name: string, relations: SchemaRelations): ImpliedKeys {
+import type { AnyClosed } from "./closed.ts"
+import { memberDescriptor, membersAgree } from "./closed.ts"
+import { assertDeclarationOrderKey, assertDeclarationRecord } 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 { renderStatement, type Statement, statementDescriptor } from "./statements.ts"
+import { arrayValue, recordValue } from "./values.ts"
+
+/** Each relation's record key is its declared name. */
+function verifyRelationNames(name: string, relations: SchemaRelations): void {
 	assertDeclarationRecord(`schema ${name} relations`, relations)
-	const rendered = new Set<string>()
-	const roster = new Map<string, ReadonlyArray<readonly string[]>>()
 	for (const [recordKey, member] of Object.entries(relations)) {
 		assertDeclarationOrderKey(`schema ${name} relation`, recordKey)
 		if (member.name !== recordKey) {
@@ -44,16 +26,7 @@ function collectImplied(name: string, relations: SchemaRelations): ImpliedKeys {
 				message: `schema ${name}: record key ${recordKey} holds relation ${member.name} — the key must equal the relation's declared name`
 			})
 		}
-		const projections: Array<readonly string[]> = []
-		if (isClosedMember(member)) {
-			projections.push(Object.freeze(["id"]))
-		}
-		for (const projection of projections) {
-			rendered.add(`${member.name}(${projection.join(", ")}) -> ${member.name}`)
-		}
-		roster.set(member.name, Object.freeze(projections))
 	}
-	return { rendered, roster }
 }
 
 function statementOwners(statement: Statement): readonly SchemaRelation[] {
@@ -80,226 +53,6 @@ function verifyMembership(name: string, relations: SchemaRelations, statement: S
 	}
 }
 
-function bindingLiterals(set: LiteralSetSpec): readonly LiteralSpec[] {
-	if (set.kind === "one") {
-		return [set.literal]
-	}
-	return set.literals
-}
-
-function verifyBindingHandles(
-	name: string,
-	face: AnyFace,
-	binding: { readonly field: string; readonly set: LiteralSetSpec },
-	rendered: string
-): void {
-	const roster = rosterOf(sealedFieldOf(face.owner, binding.field))
-	for (const literal of bindingLiterals(binding.set)) {
-		if (literal.kind !== "handle") {
-			continue
-		}
-		if (roster === undefined) {
-			throw new AuthoringError({
-				message: `schema ${name}: ${face.owner.name}.${binding.field} is not a closed-relation reference — the handle literal ${literal.handle} is legal only on a field carrying a closed relation's roster — ${rendered}`
-			})
-		}
-		if (!roster.handles.includes(literal.handle)) {
-			throw new AuthoringError({
-				message: `schema ${name}: closed relation ${roster.name} has no handle ${literal.handle} — ${rendered}`
-			})
-		}
-	}
-}
-
-function verifyHandles(name: string, statement: Statement, rendered: string): void {
-	const data = statement
-	if (data.kind === "key") {
-		return
-	}
-	for (const face of [data.source, data.target]) {
-		for (const binding of face.selection) {
-			verifyBindingHandles(name, face, binding, rendered)
-		}
-	}
-}
-
-function closedTargetOf(statements: readonly Statement[], owner: string, field: string): string | undefined {
-	for (const statement of statements) {
-		const data = statement
-		if (data.kind !== "containment" && data.kind !== "mirrors") {
-			continue
-		}
-		const pairs: Array<readonly [AnyFace, AnyFace]> = [[data.source, data.target]]
-		if (data.kind === "mirrors") {
-			pairs.push([data.target, data.source])
-		}
-		for (const [source, target] of pairs) {
-			if (
-				source.owner.name === owner &&
-				source.projection.length === 1 &&
-				source.projection[0] === field &&
-				target.projection.length === 1 &&
-				target.projection[0] === "id" &&
-				isClosedMember(target.owner)
-			) {
-				return target.owner.name
-			}
-		}
-	}
-	return undefined
-}
-
-function verifyClosedReferences(name: string, statements: readonly Statement[]): void {
-	for (const statement of statements) {
-		const data = statement
-		if (data.kind === "key") {
-			continue
-		}
-		const rendered = renderStatement(statement)
-		for (const face of [data.source, data.target]) {
-			for (const binding of face.selection) {
-				verifyClosedReferenceBinding(name, statements, face, binding, rendered)
-			}
-		}
-	}
-}
-
-function verifyClosedReferenceBinding(
-	name: string,
-	statements: readonly Statement[],
-	face: AnyFace,
-	binding: { readonly field: string; readonly set: LiteralSetSpec },
-	rendered: string
-): void {
-	const spellsHandle = bindingLiterals(binding.set).some(function isHandle(literal) {
-		return literal.kind === "handle"
-	})
-	if (!spellsHandle) {
-		return
-	}
-	const roster = rosterOf(sealedFieldOf(face.owner, binding.field))
-	if (roster === undefined) {
-		return
-	}
-	if (isClosedMember(face.owner) && binding.field === "id") {
-		return
-	}
-	const resolved = closedTargetOf(statements, face.owner.name, binding.field)
-	if (resolved !== roster.name) {
-		throw new AuthoringError({
-			message: `schema ${name}: ${face.owner.name}.${binding.field} spells a ${roster.name} handle, but no declared containment resolves the closed reference — a closed reference is the plain u64 column plus its declared containment; declare contained(on(${face.owner.name}, "${binding.field}"), on(${roster.name}, "id")) — ${rendered}`
-		})
-	}
-}
-
-/**
- * THE TARGET-KEY WALL, value tier (60-containment-parity — the runtime
- * twin of `law.ts`'s `TargetKeyWall`, the engine's `resolve_target_key` /
- * `resolve_capacity_target` mirrored exactly): every `contained`/
- * `mirrors`/`capacity` statement's target projection must resolve a key
- * of the target relation, judged over the SAME key population the engine
- * materializes — the closed auto-keys
- * ({@link collectImplied}'s roster) first, then the declared `key`
- * statements in written order (a key may be declared after its probe, so
- * this wall runs over the COMPLETE list, never inside the statement
- * loop). `mirrors` materializes as two containments source-first, so both
- * orientations judge their own target. SOUNDNESS BAR: the set-match +
- * closed-id rule below is the engine's COMPLETE rule for this law
- * (`matching_functionality` compares field SETS — permutations resolve,
- * subsets/supersets refuse), so this wall never rejects what the engine
- * accepts; every other schema judgment stays engine-first.
- */
-function verifyTargetKeys(
-	name: string,
-	statements: readonly Statement[],
-	implied: ReadonlyMap<string, ReadonlyArray<readonly string[]>>
-): void {
-	const declared = new Map<string, Array<readonly string[]>>()
-	for (const statement of statements) {
-		const data = statement
-		if (data.kind !== "key") {
-			continue
-		}
-		const keys = declared.get(data.owner.name)
-		if (keys === undefined) {
-			declared.set(data.owner.name, [data.projection])
-		} else {
-			keys.push(data.projection)
-		}
-	}
-	for (const statement of statements) {
-		const data = statement
-		if (data.kind === "key") {
-			continue
-		}
-		const rendered = renderStatement(statement)
-
-		const faces = data.kind === "mirrors" ? [data.target, data.source] : [data.target]
-		for (const face of faces) {
-			verifyTargetKeyFace(name, face, implied, declared, rendered)
-		}
-	}
-}
-
-/**
- * One target face's key resolution (the {@link verifyTargetKeys} leaf).
- * Closed target: the handle id is the ONE probe-able identity of a closed
- * relation, so the projection must be exactly `["id"]` — its own refusal
- * (the engine's `ClosedTargetNotHandle`): the rule is CLOSEDNESS, not key
- * absence. Ordinary target: the projection's field-name SET must equal
- * some roster member's set (the engine's `matching_functionality` —
- * permutations resolve, subsets and supersets do not). The refusal speaks
- * the engine's shape in NAMES, with the engine's pointwise hint verbatim
- * when the projection carries an interval position.
- */
-function verifyTargetKeyFace(
-	name: string,
-	face: AnyFace,
-	implied: ReadonlyMap<string, ReadonlyArray<readonly string[]>>,
-	declared: ReadonlyMap<string, ReadonlyArray<readonly string[]>>,
-	rendered: string
-): void {
-	if (isClosedMember(face.owner)) {
-		if (face.projection.length === 1 && face.projection[0] === "id") {
-			return
-		}
-		throw new AuthoringError({
-			message: `schema ${name}: ${rendered}: closed target ${face.owner.name} is addressed by its synthetic id only — projection (${face.projection.join(", ")}) must be exactly (id) (rewrite the target side as on(${face.owner.name}, "id"))`
-		})
-	}
-	const roster = [...(implied.get(face.owner.name) ?? []), ...(declared.get(face.owner.name) ?? [])]
-	const want = new Set(face.projection)
-	const matched = roster.some(function sameFieldSet(key) {
-		// engine's FieldSet refuses (duplicates are refused at the key()
-
-		if (key.length !== face.projection.length || want.size !== face.projection.length) {
-			return false
-		}
-		const keySet = new Set(key)
-		if (keySet.size !== want.size) {
-			return false
-		}
-		for (const field of keySet) {
-			if (!want.has(field)) {
-				return false
-			}
-		}
-		return true
-	})
-	if (matched) {
-		return
-	}
-	const available = roster.length === 0 ? "none" : roster.map((key) => `(${key.join(", ")})`).join("; ")
-	const pointwise = face.projection.some(function carriesInterval(fieldName) {
-		const descriptor = sealedFieldOf(face.owner, fieldName)
-		return descriptor !== undefined && descriptor.kind === "interval"
-	})
-	const hint = pointwise ? "; hint: declare the exact pointwise key `R(prefix…, interval) -> R`" : ""
-	throw new AuthoringError({
-		message: `schema ${name}: ${rendered}: target projection (${face.projection.join(", ")}) matches no declared key of ${face.owner.name} — available keys: ${available}${hint}`
-	})
-}
-
 type SchemaRelation = AnyRelation | AnyClosed
 
 type SchemaRelations = Record<string, SchemaRelation>
@@ -351,7 +104,7 @@ 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)
+	return isCompiledSchema(input) && isImmutable(input) ? input : checkedSchema(input)
 }
 
 const checkedSchema = descriptorCache((input): AnySchema => {
@@ -394,29 +147,15 @@ function schema<const Rels extends SchemaRelations, const Stmts extends readonly
 	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 ownedStatements) {
-		const rendered = renderStatement(statement)
-		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`
-			})
-		}
-		if (seen.has(rendered)) {
-			throw new AuthoringError({ message: `schema ${name}: duplicate statement — ${rendered}` })
-		}
-		seen.add(rendered)
-		verifyHandles(name, statement, rendered)
-	}
-	verifyClosedReferences(name, ownedStatements)
-	verifyTargetKeys(name, ownedStatements, implied.roster)
+	verifyRelationNames(name, ownedRelations)
+	for (const statement of ownedStatements) verifyMembership(name, ownedRelations, statement, renderStatement(statement))
 	const classes = computeClasses(name, ownedRelations, ownedStatements)
 	if (!classesComplete<EvaluatedClasses<ClassesOf<Rels, Stmts>>>(classes, ownedRelations)) {
-		throw new SdkInvariantError({ message: `schema ${name}: class-map construction incomplete` })
+		throw internalError(`schema ${name}: class-map construction incomplete`)
 	}
-	return Object.freeze({ name, relations: ownedRelations, statements: Object.freeze(ownedStatements), classes })
+	const result = Object.freeze({ name, relations: ownedRelations, statements: Object.freeze(ownedStatements), classes })
+	registerCompiled(result)
+	return result
 }
 
 export type { AnySchema, Schema, SchemaRelation, SchemaRelations }

package/src/selection.ts

@@ -1,9 +1,9 @@
-import { type AnyClosed, memberDescriptor, sealedFieldOf, sealedFieldsOf } from "#closed.ts"
-import { AuthoringError } from "#errors.ts"
-import { type AnyField, assertDeclarationRecord, type ClosedIdField, type Infer, literalOf } from "#fields.ts"
-import type { AnyRelation, RelationFields } from "#relation.ts"
-import { type LiteralSetSpec, type LiteralSpec, renderLiteral } from "#spec.ts"
-import { arrayValue, recordValue } from "#values.ts"
+import { type AnyClosed, memberDescriptor, sealedFieldOf, sealedFieldsOf } from "./closed.ts"
+import { AuthoringError } from "./errors.ts"
+import { type AnyField, assertDeclarationRecord, type ClosedIdField, type Infer, literalOf } from "./fields.ts"
+import type { AnyRelation, RelationFields } from "./relation.ts"
+import { type LiteralSetSpec, type LiteralSpec, renderLiteral } from "./spec.ts"
+import { arrayValue, recordValue } from "./values.ts"
 
 type Selectable = AnyRelation | AnyClosed
 type FieldsOf<R extends Selectable> = R extends AnyRelation

package/src/shape.ts

@@ -1,5 +1,5 @@
-import type { Query } from "#query/lower.ts"
-import type { inferred, ParamsRecord } from "#query/scope.ts"
+import type { Query } from "./query/lower.ts"
+import type { inferred, ParamsRecord } from "./query/scope.ts"
 /**
  * Shared derived types: `S` is a
  * declared core schema value's type, `Rel<S>` its ordinary (writable)
@@ -8,9 +8,9 @@ import type { inferred, ParamsRecord } from "#query/scope.ts"
  * immutable schema-bound logical query template. All are derived from the
  * existing typed descriptors — no second hand-maintained roster.
  */
-import type { AnyRelation, Fact } from "#relation.ts"
-import type { AnySchema } from "#schema.ts"
-import type { KeyStatement } from "#statements.ts"
+import type { AnyRelation, Fact } from "./relation.ts"
+import type { AnySchema } from "./schema.ts"
+import type { KeyStatement } from "./statements.ts"
 
 /** The ordinary relations of a schema (closed vocabularies are ground axioms, never ingestion targets). */
 type Rel<S extends AnySchema> = Extract<S["relations"][keyof S["relations"]], AnyRelation>

package/src/spec.ts

@@ -1,19 +1,5 @@
 import { regex } from "arkregex"
 
-type ValueTypeSpec =
-	| { readonly kind: "bool" }
-	| { readonly kind: "u64" }
-	| { readonly kind: "i64" }
-	| { readonly kind: "f64" }
-	| { readonly kind: "uuid" }
-	| { readonly kind: "string" }
-	| { readonly kind: "fixedBytes"; readonly len: number }
-	| {
-			readonly kind: "interval"
-			readonly element: "u64" | "i64" | "f64"
-			readonly width: bigint | undefined
-	  }
-
 type ValueSpec =
 	| { readonly kind: "bool"; readonly value: boolean }
 	| { readonly kind: "u64"; readonly value: bigint }
@@ -26,6 +12,11 @@ type ValueSpec =
 	| { readonly kind: "intervalI64"; readonly start: bigint; readonly end: bigint }
 	| { readonly kind: "intervalF64"; readonly start: number; readonly end: number }
 
+/** A tagged value on the data plane: a query param, or a member of a set param. */
+type TaggedValue = ValueSpec
+
+type QueryParam = TaggedValue | { readonly kind: "set"; readonly values: readonly TaggedValue[] }
+
 type LiteralSpec =
 	| { readonly kind: "value"; readonly value: ValueSpec }
 	| { readonly kind: "handle"; readonly handle: string }
@@ -34,12 +25,6 @@ type LiteralSetSpec =
 	| { readonly kind: "one"; readonly literal: LiteralSpec }
 	| { readonly kind: "many"; readonly literals: readonly LiteralSpec[] }
 
-interface SideSpec {
-	readonly relation: string
-	readonly projection: readonly string[]
-	readonly selection: ReadonlyArray<readonly [string, LiteralSetSpec]>
-}
-
 type CapacityBoundSpec =
 	| { readonly kind: "lit"; readonly value: bigint }
 	| { readonly kind: "field"; readonly field: string }
@@ -55,64 +40,6 @@ type CapacityWindowSpec =
 	| { readonly kind: "range"; readonly lo: CapacityBoundSpec; readonly hi: CapacityBoundSpec }
 	| { readonly kind: "floor"; readonly lo: CapacityBoundSpec }
 
-/**
- * One field: name, structural type, and host newtype label. There is no
- * `fresh` mark: the database issues no identity, and key laws are declared
- * statements.
- */
-interface FieldSpec {
-	readonly name: string
-	readonly valueType: ValueTypeSpec
-	readonly newtype: string | undefined
-}
-
-interface RowSpec {
-	readonly handle: string
-	readonly values: readonly LiteralSpec[]
-}
-
-/**
- * A relation's closedness as ONE sum (ruled 2026-07-23, R7): the handle
- * newtype and the ground axioms travel together — the two illegal states
- * (a roster without its newtype, a newtype without its roster) are
- * unspellable on the wire exactly as they are unrepresentable in the
- * fused Rust `RelationSpec`. `newtype` is the id's law-computed generator
- * class (`` `${name}.id` `` — the same label every referencing field
- * carries by law), which is how the engine resolves a handle literal back
- * to its roster.
- */
-interface ClosedSpec {
-	readonly newtype: string
-	readonly rows: readonly RowSpec[]
-}
-
-interface RelationSpec {
-	readonly name: string
-	readonly fields: readonly FieldSpec[]
-	readonly closed: ClosedSpec | undefined
-}
-
-type StatementSpec =
-	| { readonly kind: "fd"; readonly relation: string; readonly projection: readonly string[] }
-	| {
-			readonly kind: "containment"
-			readonly source: SideSpec
-			readonly target: SideSpec
-			readonly bidirectional: boolean
-	  }
-	| {
-			readonly kind: "capacity"
-			readonly target: SideSpec
-			readonly weight: WeightSpec
-			readonly window: CapacityWindowSpec
-			readonly source: SideSpec
-	  }
-
-interface SchemaSpec {
-	readonly relations: readonly RelationSpec[]
-	readonly statements: readonly StatementSpec[]
-}
-
 const NON_PRINTABLE = regex("[\\p{C}\\p{Z}]", "u")
 
 const GRAPHEME_EXTEND = regex("\\p{Grapheme_Extend}", "u")
@@ -263,16 +190,11 @@ function renderWeight(weight: WeightSpec): string {
 export type {
 	CapacityBoundSpec,
 	CapacityWindowSpec,
-	FieldSpec,
 	LiteralSetSpec,
 	LiteralSpec,
-	RelationSpec,
-	RowSpec,
-	SchemaSpec,
-	SideSpec,
-	StatementSpec,
+	QueryParam,
+	TaggedValue,
 	ValueSpec,
-	ValueTypeSpec,
 	WeightSpec
 }
 export { f64BitsHex, renderCapacityWindow, renderLiteral, renderLiteralSet, renderWeight }

package/src/statements.ts

@@ -7,15 +7,15 @@ import {
 	type UnitDimensionBan,
 	unitWeight,
 	type WeightOnSource
-} from "#capacity.ts"
-import { isClosedMember, memberDescriptor, sealedFieldOf } from "#closed.ts"
-import { AuthoringError } from "#errors.ts"
-import { type AnyFace, faceDescriptor, renderFace, type SameArity, type SameShapes } from "#face.ts"
-import { type AnyClosedRoster, assertDeclarationRecord, rosterOf, rostersAgree, signaturesAgree } from "#fields.ts"
-import { descriptorCache } from "#immutable.ts"
-import type { AnyRelation, RelationFields } from "#relation.ts"
-import { type CapacityWindowSpec, renderCapacityWindow, renderWeight, type WeightSpec } from "#spec.ts"
-import { arrayValue, recordValue } from "#values.ts"
+} from "./capacity.ts"
+import { isClosedMember, memberDescriptor, sealedFieldOf } from "./closed.ts"
+import { AuthoringError } from "./errors.ts"
+import { type AnyFace, faceDescriptor, renderFace, type SameArity, type SameShapes } from "./face.ts"
+import { type AnyClosedRoster, assertDeclarationRecord, rosterOf, rostersAgree, signaturesAgree } from "./fields.ts"
+import { descriptorCache } from "./immutable.ts"
+import type { AnyRelation, RelationFields } from "./relation.ts"
+import { type CapacityWindowSpec, renderCapacityWindow, renderWeight, type WeightSpec } from "./spec.ts"
+import { arrayValue, recordValue } from "./values.ts"
 
 interface KeyStatement<R extends AnyRelation = AnyRelation, Projection extends readonly string[] = readonly string[]> {
 	readonly kind: "key"
@@ -46,7 +46,7 @@ function renderRosterSide(roster: AnyClosedRoster | undefined): string {
 }
 
 /**
- * The runtime twin of {@link SameArity} (cleanup-0.5.0 ruling 9): the two
+ * The runtime twin of {@link SameArity}: the two
  * faces must project equally many fields, judged at CONSTRUCTION for
  * untyped callers too — without it an arity-mismatched containment
  * silently truncates to the shorter projection (this module's positionwise
@@ -195,7 +195,7 @@ const checkedStatement = descriptorCache((raw): Statement => {
 	if (statement.kind === "capacity") {
 		const { weight, window } = statement
 		if (weight.kind === "unit" && window.kind === "range" && window.hi.kind === "durationField") {
-			throw new AuthoringError({ message: "a unit (count) window against a duration bound mixes dimensions (C18)" })
+			throw new AuthoringError({ message: "a unit (count) window against a duration bound mixes dimensions" })
 		}
 		assertWeightOnSource(weight, source, statement)
 		assertBoundsOnTarget(window, target, statement)

package/src/uuid.ts

@@ -1,5 +1,5 @@
 import { Result } from "effect"
-import { DbError } from "#runtime-errors.ts"
+import { DbError } from "./errors.ts"
 
 /** Structural UUID spelling, compatible with host generators and ordinary literals.
  * Exact hexadecimal width and canonical case are checked at runtime boundaries.

package/src/values.ts

@@ -1,7 +1,7 @@
-import { type AuthoringDiagnostic, AuthoringError } from "#errors.ts"
-import type { AnyField, Infer } from "#fields.ts"
-import type { ValueSpec } from "#spec.ts"
-import { Uuid } from "#uuid.ts"
+import { type AuthoringDiagnostic, AuthoringError } from "./errors.ts"
+import type { AnyField, Infer } from "./fields.ts"
+import type { ValueSpec } from "./spec.ts"
+import { Uuid } from "./uuid.ts"
 
 const U64_MAX = 0xffffffffffffffffn
 const I64_MIN = -0x8000000000000000n

package/dist/close.d.ts

@@ -1,24 +0,0 @@
-import { Effect } from "effect";
-import type { CloseReport } from "./runtime-errors.js";
-/**
- * Shared close/drain adapters for scoped core owners (drafts, changes,
- * snapshots, sessions, results, cursors, databases). Early `close()` joins
- * the native close transition and
- * returns the honest {@link CloseReport}; a scope FINALIZER runs the same
- * close and surfaces `incomplete`/`failed` as a structured `CloseFailure`
- * DEFECT in the finalizer Cause — never catch-and-log, never false
- * quiescence. Teardown uses the runtime's reserved cleanup envelope
- * natively; repeated close joins the same stored transition (idempotent).
- */
-import type { CloseWire } from "./runtime-native.js";
-/**
- * Adapts one native close verb to `Effect<CloseReport>`: registration is
- * synchronous, completion resumes exactly once, and the whole wait is
- * uninterruptible — a close is a bounded registration/drain handshake, not
- * long maskable work (the native side owns the cleanup deadline).
- */
-declare function drainClose(operation: string, start: (callback: (report: CloseWire) => void) => void): Effect.Effect<CloseReport>;
-/** The finalizer policy: run the close, then die on incomplete/failed (E stays never). */
-declare function releaseOwner(operation: string, start: (callback: (report: CloseWire) => void) => void): Effect.Effect<void>;
-export { drainClose, releaseOwner };
-//# sourceMappingURL=close.d.ts.map

package/dist/close.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"close.d.ts","sourceRoot":"","sources":["../src/close.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAErD;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AASnD;;;;;GAKG;AACH,iBAAS,UAAU,CAClB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,KAAK,IAAI,GACpD,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAa5B;AAED,0FAA0F;AAC1F,iBAAS,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAEpH;AAED,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,CAAA"}

package/dist/close.js

@@ -1,34 +0,0 @@
-import { Effect } from "effect";
-import { finalizeClose } from "#runtime.ts";
-import { DbError } from "#runtime-errors.ts";
-function reportOf(operation, wire) {
-    if (wire.kind === "failed") {
-        return { kind: "failed", error: new DbError({ operation, reason: { _tag: "Internal" } }) };
-    }
-    return wire;
-}
-/**
- * Adapts one native close verb to `Effect<CloseReport>`: registration is
- * synchronous, completion resumes exactly once, and the whole wait is
- * uninterruptible — a close is a bounded registration/drain handshake, not
- * long maskable work (the native side owns the cleanup deadline).
- */
-function drainClose(operation, start) {
-    return Effect.callback((resume) => {
-        try {
-            start((report) => resume(Effect.succeed(reportOf(operation, report))));
-        }
-        catch (cause) {
-            resume(Effect.succeed({
-                kind: "failed",
-                error: cause instanceof DbError ? cause : new DbError({ operation, reason: { _tag: "Internal" } })
-            }));
-        }
-    }).pipe(Effect.uninterruptible);
-}
-/** The finalizer policy: run the close, then die on incomplete/failed (E stays never). */
-function releaseOwner(operation, start) {
-    return drainClose(operation, start).pipe(Effect.flatMap((report) => finalizeClose(operation, report)));
-}
-export { drainClose, releaseOwner };
-//# sourceMappingURL=close.js.map

package/dist/close.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"close.js","sourceRoot":"","sources":["../src/close.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAa5C,SAAS,QAAQ,CAAC,SAAiB,EAAE,IAAe;IACnD,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,OAAO,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,CAAA;IAC3F,CAAC;IACD,OAAO,IAAI,CAAA;AACZ,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAClB,SAAiB,EACjB,KAAsD;IAEtD,OAAO,MAAM,CAAC,QAAQ,CAAc,CAAC,MAAM,EAAE,EAAE;QAC9C,IAAI,CAAC;YACJ,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;QACvE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,MAAM,CACL,MAAM,CAAC,OAAO,CAAC;gBACd,IAAI,EAAE,QAAQ;gBACd,KAAK,EAAE,KAAK,YAAY,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,CAAC;aAClG,CAAC,CACF,CAAA;QACF,CAAC;IACF,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,CAAA;AAChC,CAAC;AAED,0FAA0F;AAC1F,SAAS,YAAY,CAAC,SAAiB,EAAE,KAAsD;IAC9F,OAAO,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;AACvG,CAAC;AAED,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,CAAA"}