@bjornpagen/bumbledb 0.20.2 → 1.0.0

package/src/schema.ts

@@ -1,3 +1,4 @@
+import { AuthoringError, SdkInvariantError } from "#errors.ts"
 /**
  * `schema` — assembles relations and statements into a theory value (the
  * `Theory` analog; what `Db.create`/`Db.open` take). Construction-time
@@ -10,12 +11,11 @@
  * 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, fresh-on-u64, …) stays the engine's `SchemaError` at
+ * 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.
  */
 
-import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import { isClosedMember, sealedFieldOf } from "#closed.ts"
 import type { FaceData } from "#face.ts"
@@ -37,19 +37,13 @@ function collectImplied(name: string, relations: SchemaRelations): ImpliedKeys {
 	for (const [recordKey, member] of Object.entries(relations)) {
 		assertDeclarationOrderKey(`schema ${name} relation`, recordKey)
 		if (member.name !== recordKey) {
-			throw errors.new(
-				`schema ${name}: record key ${recordKey} holds relation ${member.name} — the key must equal the relation's declared name`
-			)
+			throw new AuthoringError({
+				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"]))
-		} else {
-			for (const declared of member.data.fields) {
-				if ("fresh" in declared.field && declared.field.fresh === true) {
-					projections.push(Object.freeze([declared.name]))
-				}
-			}
 		}
 		for (const projection of projections) {
 			rendered.add(`${member.name}(${projection.join(", ")}) -> ${member.name}`)
@@ -71,12 +65,14 @@ function verifyMembership(name: string, relations: SchemaRelations, statement: S
 	for (const owner of statementOwners(statement)) {
 		const member = relations[owner.name]
 		if (member === undefined) {
-			throw errors.new(`schema ${name}: relation ${owner.name} is not declared in this schema — ${rendered}`)
+			throw new AuthoringError({
+				message: `schema ${name}: relation ${owner.name} is not declared in this schema — ${rendered}`
+			})
 		}
 		if (member !== owner) {
-			throw errors.new(
-				`schema ${name}: statement references a different relation value named ${owner.name} than the one this schema declares — ${rendered}`
-			)
+			throw new AuthoringError({
+				message: `schema ${name}: statement references a different relation value named ${owner.name} than the one this schema declares — ${rendered}`
+			})
 		}
 	}
 }
@@ -100,12 +96,14 @@ function verifyBindingHandles(
 			continue
 		}
 		if (roster === undefined) {
-			throw errors.new(
-				`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}`
-			)
+			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 errors.new(`schema ${name}: closed relation ${roster.name} has no handle ${literal.handle} — ${rendered}`)
+			throw new AuthoringError({
+				message: `schema ${name}: closed relation ${roster.name} has no handle ${literal.handle} — ${rendered}`
+			})
 		}
 	}
 }
@@ -185,9 +183,9 @@ function verifyClosedReferenceBinding(
 	}
 	const resolved = closedTargetOf(statements, face.owner.name, binding.field)
 	if (resolved !== roster.name) {
-		throw errors.new(
-			`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}`
-		)
+		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}`
+		})
 	}
 }
 
@@ -197,7 +195,7 @@ function verifyClosedReferenceBinding(
  * `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 fresh-implied and closed auto-keys
+ * 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
@@ -262,9 +260,9 @@ function verifyTargetKeyFace(
 		if (face.projection.length === 1 && face.projection[0] === "id") {
 			return
 		}
-		throw errors.new(
-			`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"))`
-		)
+		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)
@@ -294,9 +292,9 @@ function verifyTargetKeyFace(
 		return descriptor !== undefined && descriptor.kind === "interval"
 	})
 	const hint = pointwise ? "; hint: declare the exact pointwise key `R(prefix…, interval) -> R`" : ""
-	throw errors.new(
-		`schema ${name}: ${rendered}: target projection (${face.projection.join(", ")}) matches no declared key of ${face.owner.name} — available keys: ${available}${hint}`
-	)
+	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
@@ -325,19 +323,19 @@ function schema<const Rels extends SchemaRelations, const Stmts extends readonly
 	const seen = new Set<string>()
 	for (const statement of statements) {
 		if (!isStatement(statement)) {
-			throw errors.new(
-				`schema ${name}: a statement is minted only by key/contained/mirrors/capacity — a structural literal skips the construction-time arity and roster walls`
-			)
+			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`
+			})
 		}
 		const rendered = renderStatement(statement)
 		verifyMembership(name, relations, statement, rendered)
 		if (implied.rendered.has(rendered)) {
-			throw errors.new(
-				`schema ${name}: ${rendered} is redundant here (the fresh mark or closedness already implies it) — and rejected as a duplicate`
-			)
+			throw new AuthoringError({
+				message: `schema ${name}: ${rendered} is redundant here (closedness already implies it) — and rejected as a duplicate`
+			})
 		}
 		if (seen.has(rendered)) {
-			throw errors.new(`schema ${name}: duplicate statement — ${rendered}`)
+			throw new AuthoringError({ message: `schema ${name}: duplicate statement — ${rendered}` })
 		}
 		seen.add(rendered)
 		verifyHandles(name, statement, rendered)
@@ -346,7 +344,7 @@ function schema<const Rels extends SchemaRelations, const Stmts extends readonly
 	verifyTargetKeys(name, statements, implied.roster)
 	const classes = computeClasses(name, relations, statements)
 	if (!classesComplete<EvaluatedClasses<ClassesOf<Rels, Stmts>>>(classes, relations)) {
-		throw errors.new(`schema ${name}: class-map construction incomplete`)
+		throw new SdkInvariantError({ message: `schema ${name}: class-map construction incomplete` })
 	}
 	return Object.freeze({ name, relations, statements: Object.freeze([...statements]), classes })
 }

package/src/shape.ts

@@ -0,0 +1,31 @@
+import type { Query } from "#query/lower.ts"
+import type { ParamsRecord } from "#query/scope.ts"
+/**
+ * Shared derived-type vocabulary of the chapter 35 core roster: `S` is a
+ * declared core schema value's type, `Rel<S>` its ordinary (writable)
+ * relations, `Fact<R>` the inferred row object, `Key<R>` the primary-key
+ * object accepted by `QueryReader.get`, and `QueryTemplate<S, P, A>` the
+ * 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"
+
+/** 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>
+
+/**
+ * The primary-key object of a relation: the fields of its FIRST
+ * materialized key statement (a closed relation's synthetic `(id)`,
+ * otherwise the first declared `key`). Keys are declared statements now —
+ * there is no fresh-implied key — so the exact projection is a schema
+ * fact, verified at execution against the compiled tables; the type admits
+ * any subset of the fact's own fields and the runtime refuses a mismatch
+ * with a typed `DbError` before any native work.
+ */
+type Key<R extends AnyRelation> = Partial<Fact<R>>
+
+/** Chapter 35's spelling of the immutable typed query template. */
+type QueryTemplate<S extends AnySchema, P extends ParamsRecord, A> = Query<S["relations"], A, P>
+
+export type { Key, QueryTemplate, Rel }

package/src/spec.ts

@@ -4,11 +4,13 @@ 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"
+			readonly element: "u64" | "i64" | "f64"
 			readonly width: bigint | undefined
 	  }
 
@@ -16,10 +18,13 @@ type ValueSpec =
 	| { readonly kind: "bool"; readonly value: boolean }
 	| { readonly kind: "u64"; readonly value: bigint }
 	| { readonly kind: "i64"; readonly value: bigint }
+	| { readonly kind: "f64"; readonly value: number }
+	| { readonly kind: "uuid"; readonly value: string }
 	| { readonly kind: "string"; readonly value: string }
 	| { readonly kind: "fixedBytes"; readonly value: Uint8Array }
 	| { readonly kind: "intervalU64"; readonly start: bigint; readonly end: bigint }
 	| { readonly kind: "intervalI64"; readonly start: bigint; readonly end: bigint }
+	| { readonly kind: "intervalF64"; readonly start: number; readonly end: number }
 
 type LiteralSpec =
 	| { readonly kind: "value"; readonly value: ValueSpec }
@@ -50,11 +55,15 @@ 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 (C01, chapter 30).
+ */
 interface FieldSpec {
 	readonly name: string
 	readonly valueType: ValueTypeSpec
 	readonly newtype: string | undefined
-	readonly fresh: boolean
 }
 
 interface RowSpec {
@@ -170,6 +179,10 @@ function renderLiteral(literal: LiteralSpec): string {
 		case "u64":
 		case "i64":
 			return value.value.toString()
+		case "f64":
+			return `f64:0x${f64BitsHex(value.value)}`
+		case "uuid":
+			return `uuid:${value.value}`
 		case "string": {
 			let out = '"'
 			for (const ch of value.value) {
@@ -187,7 +200,24 @@ function renderLiteral(literal: LiteralSpec): string {
 		case "intervalU64":
 		case "intervalI64":
 			return `${value.start}..${value.end}`
+		case "intervalF64":
+			return `f64:0x${f64BitsHex(value.start)}..f64:0x${f64BitsHex(value.end)}`
+	}
+}
+
+/**
+ * The canonical binary64 bit image as sixteen lowercase hex digits — the
+ * one f64 rendering (chapter 11): every NaN is the quiet canonical NaN and
+ * `-0` renders as `+0`, mirroring the engine's `f64:0x{bits:016x}`.
+ */
+function f64BitsHex(value: number): string {
+	const image = new DataView(new ArrayBuffer(8))
+	if (Number.isNaN(value)) {
+		image.setBigUint64(0, 0x7ff8000000000000n)
+	} else {
+		image.setFloat64(0, value === 0 ? 0 : value)
 	}
+	return image.getBigUint64(0).toString(16).padStart(16, "0")
 }
 
 function renderLiteralSet(set: LiteralSetSpec): string {
@@ -245,4 +275,4 @@ export type {
 	ValueTypeSpec,
 	WeightSpec
 }
-export { renderCapacityWindow, renderLiteral, renderLiteralSet, renderWeight }
+export { f64BitsHex, renderCapacityWindow, renderLiteral, renderLiteralSet, renderWeight }

package/src/statements.ts

@@ -1,4 +1,3 @@
-import * as errors from "@superbuilders/errors"
 import {
 	type BoundsOnTarget,
 	type CapacityWeight,
@@ -6,11 +5,11 @@ import {
 	isCapacityWeight,
 	isCapacityWindow,
 	type UnitDimensionBan,
-	type UnitWindowBan,
 	unitWeight,
 	type WeightOnSource
 } from "#capacity.ts"
 import { isClosedMember, sealedFieldOf } from "#closed.ts"
+import { AuthoringError } from "#errors.ts"
 import { type AnyFace, type FaceData, renderFace, type SameArity, type SameShapes } from "#face.ts"
 import { type AnyClosedRoster, rosterOf, rostersAgree } from "#fields.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
@@ -82,9 +81,9 @@ function renderRosterSide(roster: AnyClosedRoster | undefined): string {
  */
 function assertArityAgreement(source: FaceData, target: FaceData, statement: Statement): void {
 	if (source.projection.length !== target.projection.length) {
-		throw errors.new(
-			`${source.owner.name}(${source.projection.join(", ")}) and ${target.owner.name}(${target.projection.join(", ")}) project ${source.projection.length} vs ${target.projection.length} fields — positional pairing requires both faces to project equally many — ${renderStatement(statement)}`
-		)
+		throw new AuthoringError({
+			message: `${source.owner.name}(${source.projection.join(", ")}) and ${target.owner.name}(${target.projection.join(", ")}) project ${source.projection.length} vs ${target.projection.length} fields — positional pairing requires both faces to project equally many — ${renderStatement(statement)}`
+		})
 	}
 }
 
@@ -97,9 +96,9 @@ function assertRosterAgreement(source: FaceData, target: FaceData, statement: St
 		const sourceRoster = rosterOf(sealedFieldOf(source.owner, fieldName))
 		const targetRoster = rosterOf(sealedFieldOf(target.owner, targetField))
 		if (!rostersAgree(sourceRoster, targetRoster)) {
-			throw errors.new(
-				`${source.owner.name}.${fieldName} is ${renderRosterSide(sourceRoster)} but ${target.owner.name}.${targetField} is ${renderRosterSide(targetRoster)} — closedness rides the descriptor: a closed reference is spelled with the vocabulary's own id descriptor (one meaning, one spelling), so faces pair closed-with-closed through one roster or bare-with-bare, never across — ${renderStatement(statement)}`
-			)
+			throw new AuthoringError({
+				message: `${source.owner.name}.${fieldName} is ${renderRosterSide(sourceRoster)} but ${target.owner.name}.${targetField} is ${renderRosterSide(targetRoster)} — closedness rides the descriptor: a closed reference is spelled with the vocabulary's own id descriptor (one meaning, one spelling), so faces pair closed-with-closed through one roster or bare-with-bare, never across — ${renderStatement(statement)}`
+			})
 		}
 	})
 }
@@ -125,16 +124,16 @@ function key<
 	const Projection extends readonly [keyof RelationFields<R> & string, ...(keyof RelationFields<R> & string)[]]
 >(relation: R, fields: Projection): KeyStatement<R, Projection> {
 	if (isClosedMember(relation)) {
-		throw errors.new(
-			`key(${relation.name}, ...): closedness already materializes ${relation.name}(id) -> ${relation.name} — an explicit key on a closed relation is rejected as a duplicate`
-		)
+		throw new AuthoringError({
+			message: `key(${relation.name}, ...): closedness already materializes ${relation.name}(id) -> ${relation.name} — an explicit key on a closed relation is rejected as a duplicate`
+		})
 	}
 	const seen = new Set<string>()
 	for (const fieldName of fields) {
 		if (seen.has(fieldName)) {
-			throw errors.new(
-				`key(${relation.name}, ...): the projection spells ${fieldName} twice — write it once (the canonical-utterance law: one meaning, one spelling)`
-			)
+			throw new AuthoringError({
+				message: `key(${relation.name}, ...): the projection spells ${fieldName} twice — write it once (the canonical-utterance law: one meaning, one spelling)`
+			})
 		}
 		seen.add(fieldName)
 	}
@@ -182,19 +181,19 @@ function assertWeightOnSource(weight: WeightSpec, source: FaceData, statement: S
 	}
 	const field = sealedFieldOf(source.owner, weight.field)
 	if (field === undefined) {
-		throw errors.new(
-			`${source.owner.name} has no field ${weight.field} — a weight names a field of the SOURCE's own row (the weight vocabulary is closed at the row) — ${renderStatement(statement)}`
-		)
+		throw new AuthoringError({
+			message: `${source.owner.name} has no field ${weight.field} — a weight names a field of the SOURCE's own row (the weight vocabulary is closed at the row) — ${renderStatement(statement)}`
+		})
 	}
 	if (weight.kind === "field" && field.kind !== "u64") {
-		throw errors.new(
-			`${source.owner.name}.${weight.field} is ${field.kind}, not u64 — a weight is u64-encoded (a signed weight would break the polarity scheduler: an insert could lower a sum) — ${renderStatement(statement)}`
-		)
+		throw new AuthoringError({
+			message: `${source.owner.name}.${weight.field} is ${field.kind}, not u64 — a weight is u64-encoded (a signed weight would break the polarity scheduler: an insert could lower a sum) — ${renderStatement(statement)}`
+		})
 	}
 	if (weight.kind === "durationField" && field.kind !== "interval") {
-		throw errors.new(
-			`${source.owner.name}.${weight.field} is ${field.kind}, not an interval — Duration(...) weighs an interval field's measure — ${renderStatement(statement)}`
-		)
+		throw new AuthoringError({
+			message: `${source.owner.name}.${weight.field} is ${field.kind}, not an interval — Duration(...) weighs an interval field's measure — ${renderStatement(statement)}`
+		})
 	}
 }
 
@@ -206,75 +205,83 @@ function assertBoundsOnTarget(window: CapacityWindowSpec, target: FaceData, stat
 		}
 		const field = sealedFieldOf(target.owner, bound.field)
 		if (field === undefined) {
-			throw errors.new(
-				`${target.owner.name} has no field ${bound.field} — a dependent bound names a field of the TARGET's own row (bound names resolve against the target's full roster) — ${renderStatement(statement)}`
-			)
+			throw new AuthoringError({
+				message: `${target.owner.name} has no field ${bound.field} — a dependent bound names a field of the TARGET's own row (bound names resolve against the target's full roster) — ${renderStatement(statement)}`
+			})
 		}
 		if (bound.kind === "field" && field.kind !== "u64") {
-			throw errors.new(
-				`${target.owner.name}.${bound.field} is ${field.kind}, not u64 — a dependent bound reads a u64 field of the TARGET row (Duration(...) is the interval-measure spelling) — ${renderStatement(statement)}`
-			)
+			throw new AuthoringError({
+				message: `${target.owner.name}.${bound.field} is ${field.kind}, not u64 — a dependent bound reads a u64 field of the TARGET row (Duration(...) is the interval-measure spelling) — ${renderStatement(statement)}`
+			})
 		}
 		if (bound.kind === "durationField" && field.kind !== "interval") {
-			throw errors.new(
-				`${target.owner.name}.${bound.field} is ${field.kind}, not an interval — Duration(...) bounds by an interval field's measure — ${renderStatement(statement)}`
-			)
+			throw new AuthoringError({
+				message: `${target.owner.name}.${bound.field} is ${field.kind}, not an interval — Duration(...) bounds by an interval field's measure — ${renderStatement(statement)}`
+			})
 		}
 	}
 }
 
+/**
+ * The chapter 34 NAMED-OPTIONS capacity call — it replaces the old four
+ * positional arguments: `capacity(target, { from, weight?, within })`.
+ * Unit weight is the default; `weigh(...)`/`within(...)` remain the only
+ * mints for the weight/window values.
+ */
 function capacity<B extends AnyFace, W extends CapacityWindow, A extends AnyFace>(
 	target: B,
-	window: W & UnitWindowBan<W> & UnitDimensionBan<W> & BoundsOnTarget<W, B>,
-	source: A & SameArity<B, A> & SameShapes<B, A>
+	options: {
+		readonly from: A & SameArity<B, A> & SameShapes<B, A>
+		readonly within: W & UnitDimensionBan<W> & BoundsOnTarget<W, B>
+	}
 ): CapacityStatement<B["data"], A["data"]>
 function capacity<B extends AnyFace, M extends CapacityWeight, W extends CapacityWindow, A extends AnyFace>(
 	target: B,
-	weight: M & WeightOnSource<M, A>,
-	window: W & BoundsOnTarget<W, B>,
-	source: A & SameArity<B, A> & SameShapes<B, A>
+	options: {
+		readonly from: A & SameArity<B, A> & SameShapes<B, A>
+		readonly weight: M & WeightOnSource<M, A>
+		readonly within: W & BoundsOnTarget<W, B>
+	}
 ): CapacityStatement<B["data"], A["data"]>
 function capacity(
 	target: AnyFace,
-	second: unknown,
-	third: unknown,
-	fourth?: AnyFace
+	options: {
+		readonly from: AnyFace
+		readonly weight?: unknown
+		readonly within: unknown
+	}
 ): CapacityStatement<FaceData, FaceData> {
-	const weighted = fourth !== undefined
-	const windowValue = weighted ? third : second
-	const source = weighted ? fourth : (third as AnyFace)
+	if (typeof options !== "object" || options === null || !("from" in options) || !("within" in options)) {
+		throw new AuthoringError({
+			message:
+				"capacity takes named options — capacity(target, { from, weight?, within }) (chapter 34's one spelling; the positional arguments are deleted)"
+		})
+	}
+	const windowValue = options.within
+	const source = options.from
 	if (!isCapacityWindow(windowValue)) {
-		throw errors.new(
-			"a capacity window is minted only by within() — a structural literal skips the ban table (the canonical-utterance law)"
-		)
+		throw new AuthoringError({
+			message:
+				"a capacity window is minted only by within() — a structural literal skips the ban table (the canonical-utterance law)"
+		})
 	}
 	let weight: WeightSpec = unitWeight
-	if (weighted) {
-		if (!isCapacityWeight(second)) {
-			throw errors.new(
-				"a capacity weight is minted only by weigh() — a structural literal skips the row-local weight wall"
-			)
+	if (options.weight !== undefined) {
+		if (!isCapacityWeight(options.weight)) {
+			throw new AuthoringError({
+				message: "a capacity weight is minted only by weigh() — a structural literal skips the row-local weight wall"
+			})
 		}
-		weight = second.weight
+		weight = options.weight.weight
 	}
 	const window = windowValue.window
-	if (weight.kind === "unit" && window.kind === "floor" && window.lo.kind === "lit" && window.lo.value === 1n) {
-		throw errors.new(
-			"`{1..*}` on the unit instance says only what the bare containment says — drop the annotation and write the containment: contained(source, target)"
-		)
-	}
-	if (weight.kind === "unit" && window.kind === "floor") {
-		throw errors.new(
-			"`{N..*}` on the unit instance — a bare count floor is refused; weigh the source (`<=[w]{N..*}` stays legal) or drop the bound"
-		)
-	}
-
-	// CapacityDimensionMixing twin — ruled 2026-07-24): a count of facts
-
+	// The unit-floor and vacuous-window ban tables are deleted (C01):
+	// `{1..*}`, `{N..*}` and `{0..*}` are accepted canonical laws now.
+	// CapacityDimensionMixing (C18) remains — genuinely different semantics.
 	if (weight.kind === "unit" && window.kind === "range" && window.hi.kind === "durationField") {
-		throw errors.new(
-			`a unit (count) window against the duration() bound on ${window.hi.field} mixes dimensions (C18) — weigh the source with weigh(duration(field)), or bound by a u64 field or literal`
-		)
+		throw new AuthoringError({
+			message: `a unit (count) window against the duration() bound on ${window.hi.field} mixes dimensions (C18) — weigh the source with weigh(duration(field)), or bound by a u64 field or literal`
+		})
 	}
 	const data: CapacityData = Object.freeze({
 		kind: "capacity",

package/src/uuid.ts

@@ -0,0 +1,69 @@
+import { Result } from "effect"
+import { DbError } from "#runtime-errors.ts"
+
+/** Structural UUID spelling, compatible with host generators and ordinary literals.
+ * Exact hexadecimal width and canonical case are checked at runtime boundaries.
+ */
+type Uuid = `${string}-${string}-${string}-${string}-${string}`
+
+const SYNTAX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+const HEX = "0123456789abcdef"
+
+function invalid(operation: string): DbError {
+	return new DbError({ operation, reason: { _tag: "InvalidArgument" } })
+}
+
+/** Pure parsing: normalize hexadecimal case, never inspect UUID version or variant. */
+function parse(text: string): Result.Result<Uuid, DbError> {
+	if (typeof text !== "string" || text.length !== 36) {
+		return Result.fail(invalid("Uuid.parse"))
+	}
+	const canonical = text.toLowerCase()
+	return isUuid(canonical) ? Result.succeed(canonical) : Result.fail(invalid("Uuid.parse"))
+}
+
+/** Canonical wire validation. No normalization is permitted at the native boundary. */
+function isUuid(value: unknown): value is Uuid {
+	return typeof value === "string" && value.length === 36 && SYNTAX.test(value)
+}
+
+/** All sixteen-byte payloads are representable, including Nil, Max, and future versions. */
+function fromBytes(bytes: Uint8Array): Result.Result<Uuid, DbError> {
+	if (!(bytes instanceof Uint8Array) || bytes.length !== 16) {
+		return Result.fail(invalid("Uuid.fromBytes"))
+	}
+	let text = ""
+	for (const byte of bytes) {
+		text += HEX.charAt(byte >>> 4)
+		text += HEX.charAt(byte & 15)
+	}
+	return Result.succeed<Uuid>(
+		`${text.slice(0, 8)}-${text.slice(8, 12)}-${text.slice(12, 16)}-${text.slice(16, 20)}-${text.slice(20)}`
+	)
+}
+
+function digit(code: number): number {
+	return code <= 57 ? code - 48 : code - 87
+}
+
+/** Validate the structural string before decoding fresh bytes in standard UUID order. */
+function toBytes(value: Uuid): Result.Result<Uint8Array, DbError> {
+	if (!isUuid(value)) {
+		return Result.fail(invalid("Uuid.toBytes"))
+	}
+	const bytes = new Uint8Array(16)
+	let offset = 0
+	for (let index = 0; index < 16; index += 1) {
+		if (value.charCodeAt(offset) === 45) {
+			offset += 1
+		}
+		bytes[index] = (digit(value.charCodeAt(offset)) << 4) | digit(value.charCodeAt(offset + 1))
+		offset += 2
+	}
+	return Result.succeed(bytes)
+}
+
+/** Generate UUIDs with a host library; preserve the result across database retries. */
+const Uuid = Object.freeze({ parse, fromBytes, toBytes, isUuid })
+
+export { Uuid }

package/dist/marshal.d.ts

@@ -1,44 +0,0 @@
-/**
- * The marshal layer: fact object ⇄ positional `FactValue[]` by field
- * ordinal, schema-directed, in ONE place only. The write side lowers named
- * host objects to rows in the relation's field-declaration order
- * (declaration order = ordinal ids, the macro's law); the read side decodes
- * rows back to named objects of BARE structural values — the marshal
- * boundary is pure both ways. CAST-FREE, LITERALLY: with structural values
- * there is no brand to assert on the way out (the historical "one
- * sanctioned marshal cast" died with the brand era), so product code
- * carries zero casts — the only trusted seams are the completeness
- * PREDICATES below, which verify the checkable half (every declared field
- * present) and rely on the store as the proof carrier for the rest: a row
- * the engine admitted IS a legal fact of its relation (the same trust
- * direction as Rust's typed readback). Shape mismatches here are genuine
- * failures and THROW typed; they are never domain data.
- *
- * THE CLOSED BIJECTION (0.4.0): a closed-referencing cell crosses this
- * boundary as its handle NAME — the write side lowers name → u64 row id
- * (declaration order = row ids, the sealed roster's own law, ≤ 256 rows),
- * the read side lifts id → name, and both directions are total and static
- * over the roster. An unknown name is a pointed THROW at the write seam —
- * a deliberate UPGRADE over 0.3.0, where any bigint sailed through the
- * marshal to a commit-time containment violation; the wrong spelling now
- * dies here, before the engine ever sees the row. An out-of-roster id on
- * the read side (reachable only in a store whose closed-typed column was
- * never pinned by its containment law) is equally pointed — never a
- * silent fallback, never `undefined`.
- */
-import type { AnyClosedRoster, AnyField } from "./fields.js";
-import type { FactValue } from "./native.js";
-import type { AnyRelation, Fact, FreshKeys, RelationData } from "./relation.js";
-declare function isFreshField(field: AnyField): boolean;
-type KeyFact<R extends AnyRelation> = [FreshKeys<R>] extends [never] ? Partial<Fact<R>> : {
-    [K in FreshKeys<R>]: Fact<R>[K];
-};
-declare function recordOf(fact: object): Readonly<Record<string, unknown>>;
-declare function handleOf(context: string, closed: AnyClosedRoster, cell: FactValue): string;
-declare function cellOf(context: string, field: AnyField, value: unknown): FactValue;
-declare function rowOf(relation: RelationData, fact: Readonly<Record<string, unknown>>): FactValue[];
-declare function keyRowOf(relation: RelationData, projection: readonly string[], key: Readonly<Record<string, unknown>>): FactValue[];
-declare function factOf<R extends AnyRelation>(relation: R, row: readonly FactValue[]): Fact<R>;
-export type { KeyFact };
-export { cellOf, factOf, handleOf, isFreshField, keyRowOf, recordOf, rowOf };
-//# sourceMappingURL=marshal.d.ts.map

package/dist/marshal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"marshal.d.ts","sourceRoot":"","sources":["../src/marshal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAE9E,iBAAS,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAE9C;AAED,KAAK,OAAO,CAAC,CAAC,SAAS,WAAW,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACjE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAChB;KAAG,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAA;AAEtC,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAKjE;AAyBD,iBAAS,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAWnF;AAED,iBAAS,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,GAAG,SAAS,CA6C3E;AAED,iBAAS,KAAK,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,CAQ3F;AAED,iBAAS,QAAQ,CAChB,QAAQ,EAAE,YAAY,EACtB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACpC,SAAS,EAAE,CAgBb;AAWD,iBAAS,MAAM,CAAC,CAAC,SAAS,WAAW,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAsBtF;AAED,YAAY,EAAE,OAAO,EAAE,CAAA;AACvB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAA"}