@bjornpagen/bumbledb-log 0.18.0 → 0.19.0

package/src/descriptor.ts

@@ -19,6 +19,7 @@ import type {
 } from "@bjornpagen/bumbledb"
 import { internalDescriptor, lower } from "@bjornpagen/bumbledb"
 import * as errors from "@superbuilders/errors"
+import { regex } from "arkregex"
 import { fromHex } from "#bytes.ts"
 import type { Value } from "#value.ts"
 
@@ -79,18 +80,95 @@ type StatementInfo =
 declare const braidBrand: unique symbol
 type Braid = string & { readonly [braidBrand]: typeof braidBrand }
 
+const BRAID_ID = regex("^c[0-9a-f]{8}$")
+const ID_CLASS = regex("^(.*)\\.id$")
+
 function braid(raw: string): Braid {
-	if (!/^c[0-9a-f]{8}$/.test(raw)) {
+	if (!BRAID_ID.test(raw)) {
 		throw errors.new(`not a braid id: ${raw}`)
 	}
 	return raw as Braid
 }
 
+function refuseShape(why: string): never {
+	throw errors.new(`theory: ${why}`)
+}
+
+/** `{name}.id` — the closed relation's generator class. */
+function idClassOwner(newtype: string): string | undefined {
+	const match = ID_CLASS.exec(newtype)
+	const owner = match?.[1]
+	if (owner === undefined || owner.length === 0) {
+		return undefined
+	}
+	return owner
+}
+
+function indexRelations(relations: readonly RelationInfo[]): Map<number, RelationInfo> {
+	const byId = new Map<number, RelationInfo>()
+	for (const relation of relations) {
+		if (byId.has(relation.id)) {
+			refuseShape(`duplicate relation id ${relation.id}`)
+		}
+		byId.set(relation.id, relation)
+	}
+	return byId
+}
+
+function relationOfId(byId: ReadonlyMap<number, RelationInfo>, id: number): RelationInfo {
+	const relation = byId.get(id)
+	if (relation === undefined) {
+		refuseShape(`unknown relation id ${id}`)
+	}
+	return relation
+}
+
+function fieldNamed(relation: RelationInfo, name: string): { readonly ordinal: number; readonly field: FieldInfo } {
+	let ordinal = 0
+	for (const field of relation.fields) {
+		if (field.name === name) {
+			return { ordinal, field }
+		}
+		ordinal += 1
+	}
+	refuseShape(`relation ${relation.name} has no field ${name}`)
+}
+
 interface SerialStatement {
 	readonly statement: number
 	readonly braid: Braid
 }
 
+function serialAtOf(
+	byId: ReadonlyMap<number, RelationInfo>,
+	statements: readonly StatementInfo[],
+	braidOfRelation: ReadonlyMap<number, Braid>
+): SerialStatement[] {
+	const serialAt: SerialStatement[] = []
+	for (const statement of statements) {
+		if (statement.kind === "functionality" && statement.projection.length === 0) {
+			const relation = relationOfId(byId, statement.relation)
+			if (relation.fields.length > 0) {
+				const braid = braidOfRelation.get(statement.relation)
+				if (braid !== undefined) {
+					serialAt.push({ statement: statement.id, braid })
+				}
+			}
+		}
+		if (statement.kind === "capacity" && statement.target.projection.length === 0) {
+			const targetRelation = relationOfId(byId, statement.target.relation)
+			if (!targetRelation.closed) {
+				const braid = braidOfRelation.get(statement.target.relation)
+				if (braid === undefined) {
+					refuseShape(`capacity ${statement.id} target ${targetRelation.name} is not in the derived braid set`)
+				}
+				serialAt.push({ statement: statement.id, braid })
+			}
+		}
+	}
+	return serialAt
+}
+
 interface Descriptor {
 	readonly relations: readonly RelationInfo[]
 	readonly relationByName: ReadonlyMap<string, RelationInfo>
@@ -146,7 +224,7 @@ function asValue(raw: unknown): Value {
 			return { start: interval.start, end: interval.end }
 		}
 	}
-	throw errors.new("sealed value is not a raw fact value")
+	refuseShape("sealed value is not a raw fact value")
 }
 
 function sideOf(side: SealedSide): SideInfo {
@@ -185,11 +263,13 @@ function statementOf(statement: SealedStatement): StatementInfo {
 
 function fromSealed(spec: SchemaSpec): Descriptor {
 	const sealed: SealedDescriptor = internalDescriptor(spec)
-	const specByName = new Map(
-		spec.relations.map(function byName(relation) {
-			return [relation.name, relation]
-		})
-	)
+	const specByName = new Map<string, SchemaSpec["relations"][number]>()
+	for (const relation of spec.relations) {
+		if (specByName.has(relation.name)) {
+			refuseShape(`duplicate relation ${relation.name}`)
+		}
+		specByName.set(relation.name, relation)
+	}
 	const closedOwners = new Set(
 		spec.relations
 			.filter(function closedOf(relation) {
@@ -202,21 +282,21 @@ function fromSealed(spec: SchemaSpec): Descriptor {
 
 	const relations: RelationInfo[] = sealed.relations.map(function relationOf(relation) {
 		const declared = specByName.get(relation.name)
+		if (declared === undefined) {
+			refuseShape(`sealed relation ${relation.name} is not in the spec`)
+		}
 		const closed = relation.extension !== undefined
 		const fields: FieldInfo[] = relation.fields.map(function fieldOf(field) {
 			if (field.name === "id" && closed) {
 				return { name: field.name, type: field.valueType, fresh: false, closedRef: relation.name }
 			}
-			const specField = declared?.fields.find(function named(candidate) {
+			const specField = declared.fields.find(function named(candidate) {
 				return candidate.name === field.name
 			})
 			let closedRef: string | undefined
-			const newtype = specField?.newtype
-			if (newtype?.endsWith(".id")) {
-				const owner = newtype.slice(0, -3)
-				if (closedOwners.has(owner)) {
-					closedRef = owner
-				}
+			const owner = specField?.newtype === undefined ? undefined : idClassOwner(specField.newtype)
+			if (owner !== undefined && closedOwners.has(owner)) {
+				closedRef = owner
 			}
 			return {
 				name: field.name,
@@ -245,7 +325,7 @@ function fromSealed(spec: SchemaSpec): Descriptor {
 				if (field.name === "id" && named.has("id")) {
 					return row.id
 				}
-				throw errors.new(`closed relation ${relation.name}: sealed row ${row.handle} missing field ${field.name}`)
+				return refuseShape(`closed relation ${relation.name}: sealed row ${row.handle} missing field ${field.name}`)
 			})
 		})
 		return {
@@ -262,30 +342,16 @@ function fromSealed(spec: SchemaSpec): Descriptor {
 
 	const byName = new Map<string, RelationInfo>()
 	for (const relation of relations) {
+		if (byName.has(relation.name)) {
+			refuseShape(`duplicate relation ${relation.name}`)
+		}
 		byName.set(relation.name, relation)
 	}
 
 	const statements = sealed.statements.map(statementOf)
-	const { braidOfRelation, braidMembers } = deriveBraids(relations, statements)
-
-	const serialAtStatements: SerialStatement[] = []
-	for (const statement of statements) {
-		if (statement.kind === "functionality" && statement.projection.length === 0) {
-			const braid = braidOfRelation.get(statement.relation)
-			if (braid !== undefined) {
-				serialAtStatements.push({ statement: statement.id, braid })
-			}
-		}
-		if (statement.kind === "capacity" && statement.target.projection.length === 0) {
-			const targetRelation = relations[statement.target.relation]
-			if (targetRelation !== undefined && !targetRelation.closed) {
-				const braid = braidOfRelation.get(statement.target.relation)
-				if (braid !== undefined) {
-					serialAtStatements.push({ statement: statement.id, braid })
-				}
-			}
-		}
-	}
+	const byId = indexRelations(relations)
+	const { braidOfRelation, braidMembers } = deriveBraids(byId, statements)
+	const serialAtStatements = serialAtOf(byId, statements, braidOfRelation)
 
 	const fingerprint = sealed.fingerprint
 	return {
@@ -342,8 +408,39 @@ function rawValue(value: ValueSpec): Value {
 
 interface SpecTables {
 	readonly spec: SchemaSpec
-	readonly relations: RelationInfo[]
 	readonly byName: Map<string, RelationInfo>
+	readonly byId: Map<number, RelationInfo>
+}
+
+function zipClosedPayload(
+	relation: RelationInfo,
+	handle: string,
+	literals: readonly LiteralSpec[]
+): Array<readonly [FieldInfo, LiteralSpec]> {
+	const pairs: Array<readonly [FieldInfo, LiteralSpec]> = []
+	const pending = literals[Symbol.iterator]()
+	let seenId = false
+	for (const field of relation.fields) {
+		if (!seenId) {
+			if (field.name !== "id") {
+				refuseShape(`closed relation ${relation.name} has no sealed id field`)
+			}
+			seenId = true
+			continue
+		}
+		const next = pending.next()
+		if (next.done) {
+			refuseShape(`closed row ${handle} of ${relation.name}: fewer cells than payload fields`)
+		}
+		pairs.push([field, next.value])
+	}
+	if (!seenId) {
+		refuseShape(`closed relation ${relation.name} has no sealed id field`)
+	}
+	if (!pending.next().done) {
+		refuseShape(`closed row ${handle} of ${relation.name}: more cells than payload fields`)
+	}
+	return pairs
 }
 
 function fieldsOf(
@@ -361,8 +458,8 @@ function fieldsOf(
 	}
 	for (const field of relation.fields) {
 		let closedRef: string | undefined
-		if (field.newtype?.endsWith(".id")) {
-			const owner = field.newtype.slice(0, -3)
+		const owner = field.newtype === undefined ? undefined : idClassOwner(field.newtype)
+		if (owner !== undefined) {
 			const target = tables.get(owner)
 			if (target?.closed === true) {
 				closedRef = owner
@@ -378,17 +475,15 @@ function resolveLiteral(tables: SpecTables, relation: RelationInfo, field: Field
 		return rawValue(literal.value)
 	}
 	if (field.closedRef === undefined) {
-		throw errors.new(
-			`handle literal ${literal.handle} on ${relation.name}.${field.name}, which references no closed roster`
-		)
+		refuseShape(`handle literal ${literal.handle} on ${relation.name}.${field.name}, which references no closed roster`)
 	}
 	const target = tables.byName.get(field.closedRef)
 	if (target === undefined) {
-		throw errors.new(`handle literal ${literal.handle}: unknown closed relation ${field.closedRef}`)
+		refuseShape(`handle literal ${literal.handle}: unknown closed relation ${field.closedRef}`)
 	}
 	const id = target.handles.indexOf(literal.handle)
 	if (id === -1) {
-		throw errors.new(`handle literal ${literal.handle} is not in the ${target.name} roster`)
+		refuseShape(`handle literal ${literal.handle} is not in the ${target.name} roster`)
 	}
 	return BigInt(id)
 }
@@ -403,29 +498,19 @@ function literalSetOf(tables: SpecTables, relation: RelationInfo, field: FieldIn
 }
 
 function fieldOrdinal(relation: RelationInfo, name: string): number {
-	const ordinal = relation.fields.findIndex(function byName(field) {
-		return field.name === name
-	})
-	if (ordinal === -1) {
-		throw errors.new(`relation ${relation.name} has no field ${name}`)
-	}
-	return ordinal
+	return fieldNamed(relation, name).ordinal
 }
 
 function specSideOf(tables: SpecTables, side: SideSpec): SideInfo {
 	const relation = tables.byName.get(side.relation)
 	if (relation === undefined) {
-		throw errors.new(`statement cites unknown relation ${side.relation}`)
+		refuseShape(`statement cites unknown relation ${side.relation}`)
 	}
 	const projection = side.projection.map(function ordinalOf(name) {
 		return fieldOrdinal(relation, name)
 	})
 	const selection = side.selection.map(function bindingOf(binding) {
-		const ordinal = fieldOrdinal(relation, binding[0])
-		const field = relation.fields[ordinal]
-		if (field === undefined) {
-			throw errors.new(`relation ${relation.name} has no field ordinal ${ordinal}`)
-		}
+		const { ordinal, field } = fieldNamed(relation, binding[0])
 		return { field: ordinal, values: literalSetOf(tables, relation, field, binding[1]) }
 	})
 	return { relation: relation.id, projection, selection }
@@ -433,7 +518,7 @@ function specSideOf(tables: SpecTables, side: SideSpec): SideInfo {
 
 function boundValue(context: string, bound: { readonly kind: string }): bigint {
 	if (bound.kind !== "lit") {
-		throw errors.new(`${context}: dependent floors are refused by the schema grammar`)
+		refuseShape(`${context}: dependent floors are refused by the schema grammar`)
 	}
 	return (bound as { readonly kind: "lit"; readonly value: bigint }).value
 }
@@ -448,7 +533,7 @@ function capacityOf(
 	const sourceRelation = tables.byName.get(statement.source.relation)
 	const targetRelation = tables.byName.get(statement.target.relation)
 	if (sourceRelation === undefined || targetRelation === undefined) {
-		throw errors.new("capacity statement cites unknown relations")
+		refuseShape("capacity statement cites unknown relations")
 	}
 	let weight: WeightInfo
 	switch (statement.weight.kind) {
@@ -504,51 +589,59 @@ function capacityOf(
 function assembleFromSpec(spec: SchemaSpec): Descriptor {
 	const prepass = new Map<string, { closed: boolean; handles: readonly string[] }>()
 	for (const relation of spec.relations) {
+		if (prepass.has(relation.name)) {
+			refuseShape(`duplicate relation ${relation.name}`)
+		}
 		prepass.set(relation.name, {
 			closed: relation.closed !== undefined,
 			handles: relation.closed === undefined ? [] : relation.closed.rows.map((row) => row.handle)
 		})
 	}
 
-	const relations: RelationInfo[] = []
 	const byName = new Map<string, RelationInfo>()
-	spec.relations.forEach(function buildRelation(relation, id) {
-		const fields = fieldsOf(prepass, relation)
+	const byId = new Map<number, RelationInfo>()
+	let nextId = 0
+	for (const relation of spec.relations) {
+		const table = prepass.get(relation.name)
+		if (table === undefined) {
+			refuseShape(`relation ${relation.name} missing from the closedness table`)
+		}
 		const info: RelationInfo = {
-			id,
+			id: nextId,
 			name: relation.name,
-			closed: relation.closed !== undefined,
-			handles: prepass.get(relation.name)?.handles ?? [],
-			fields,
+			closed: table.closed,
+			handles: table.handles,
+			fields: fieldsOf(prepass, relation),
 			rows: []
 		}
-		relations.push(info)
+		nextId += 1
 		byName.set(relation.name, info)
-	})
-	const tables: SpecTables = { spec, relations, byName }
+		byId.set(info.id, info)
+	}
+
+	const tables: SpecTables = { spec, byName, byId }
 
-	spec.relations.forEach(function resolveRows(relation, id) {
+	for (const relation of spec.relations) {
 		if (relation.closed === undefined) {
-			return
+			continue
 		}
-		const info = relations[id]
+		const info = byName.get(relation.name)
 		if (info === undefined) {
-			throw errors.new(`relation ordinal ${id} missing`)
+			refuseShape(`closed relation ${relation.name} missing`)
 		}
 		const rows = relation.closed.rows.map(function resolveRow(row, rowId) {
 			const values: Value[] = [BigInt(rowId)]
-			row.values.forEach(function resolveCell(literal, column) {
-				const field = info.fields[column + 1]
-				if (field === undefined) {
-					throw errors.new(`closed row ${row.handle} of ${relation.name}: no field at column ${column}`)
-				}
+			for (const [field, literal] of zipClosedPayload(info, row.handle, row.values)) {
 				values.push(resolveLiteral(tables, info, field, literal))
-			})
+			}
 			return values
 		})
-		relations[id] = { ...info, rows }
-		byName.set(relation.name, relations[id])
-	})
+		const updated = { ...info, rows }
+		byName.set(relation.name, updated)
+		byId.set(info.id, updated)
+	}
+
+	const relations = [...byId.values()]
 
 	const statements: StatementInfo[] = []
 	relations.forEach(function freshKeys(relation) {
@@ -568,7 +661,7 @@ function assembleFromSpec(spec: SchemaSpec): Descriptor {
 			case "fd": {
 				const relation = byName.get(statement.relation)
 				if (relation === undefined) {
-					throw errors.new(`key statement cites unknown relation ${statement.relation}`)
+					refuseShape(`key statement cites unknown relation ${statement.relation}`)
 				}
 				statements.push({
 					id: statements.length,
@@ -596,26 +689,8 @@ function assembleFromSpec(spec: SchemaSpec): Descriptor {
 		}
 	}
 
-	const { braidOfRelation, braidMembers } = deriveBraids(relations, statements)
-
-	const serialAtStatements: SerialStatement[] = []
-	for (const statement of statements) {
-		if (statement.kind === "functionality" && statement.projection.length === 0) {
-			const braid = braidOfRelation.get(statement.relation)
-			if (braid !== undefined) {
-				serialAtStatements.push({ statement: statement.id, braid })
-			}
-		}
-		if (statement.kind === "capacity" && statement.target.projection.length === 0) {
-			const targetRelation = relations[statement.target.relation]
-			if (targetRelation !== undefined && !targetRelation.closed) {
-				const braid = braidOfRelation.get(statement.target.relation)
-				if (braid !== undefined) {
-					serialAtStatements.push({ statement: statement.id, braid })
-				}
-			}
-		}
-	}
+	const { braidOfRelation, braidMembers } = deriveBraids(byId, statements)
+	const serialAtStatements = serialAtOf(byId, statements, braidOfRelation)
 
 	const fingerprint = "00".repeat(32)
 	return {
@@ -631,11 +706,11 @@ function assembleFromSpec(spec: SchemaSpec): Descriptor {
 }
 
 function deriveBraids(
-	relations: readonly RelationInfo[],
+	byId: ReadonlyMap<number, RelationInfo>,
 	statements: readonly StatementInfo[]
 ): { braidOfRelation: Map<number, Braid>; braidMembers: Map<Braid, readonly number[]> } {
 	const parent = new Map<number, number>()
-	for (const relation of relations) {
+	for (const relation of byId.values()) {
 		if (!relation.closed) {
 			parent.set(relation.id, relation.id)
 		}
@@ -661,9 +736,9 @@ function deriveBraids(
 		if (statement.kind === "functionality") {
 			continue
 		}
-		const source = relations[statement.source.relation]
-		const target = relations[statement.target.relation]
-		if (source === undefined || target === undefined || source.closed || target.closed) {
+		const source = relationOfId(byId, statement.source.relation)
+		const target = relationOfId(byId, statement.target.relation)
+		if (source.closed || target.closed) {
 			continue
 		}
 		union(source.id, target.id)

package/src/errors.ts

@@ -4,12 +4,15 @@
  * causes carried as data properties read back with the `*Of` accessors —
  * never by message-string matching. There is deliberately no
  * `ErrAlreadyApplied`: the state it would name is absorbed by idempotent
- * replay (L10) and never surfaces.
+ * replay (L10) and never surfaces. ManifestMissing, Ambiguous, OverWidth,
+ * Exhausted, and SlotRetired are named sums of their own: a replica
+ * without a manifest, an unproved conditional write, a draw past the
+ * lease width or the u64 ceiling, and a below-floor create.
  */
 
 import * as errors from "@superbuilders/errors"
 import type { Braid } from "#descriptor.ts"
-import type { Generation } from "#keys.ts"
+import type { Generation, StoreKey } from "#keys.ts"
 
 /**
  * Typed refusal of a protocol object before any apply: batch shape,
@@ -37,6 +40,25 @@ const ErrChainMismatch = errors.new("bumbledb-log chainMismatch: the batch viola
 /** Bounded live-tip losses exhausted — an operational signal, not an outcome arm. */
 const ErrContention = errors.new("bumbledb-log contention: consecutive live-tip losses exhausted the bound")
 
+/** A replica (or any read-role handle) found no manifest; only the writer births a store. */
+export const ErrManifestMissing = errors.new("bumbledb-log manifestMissing: the store has no manifest")
+
+/**
+ * A conditional write the transport cannot prove (S3 409, timeout, a
+ * retried PUT). The machine GET-verifies; this identity is the unproved
+ * arm, never a proved Exists or Moved.
+ */
+const ErrAmbiguous = errors.new("bumbledb-log ambiguous: the conditional write is unproved")
+
+/** A single id draw larger than one lease width; the width is the one block size. */
+const ErrOverWidth = errors.new("bumbledb-log overWidth: the draw exceeds the lease width")
+
+/** The next lease would leave u64 — the id space is spent. */
+const ErrExhausted = errors.new("bumbledb-log exhausted: the id space is spent")
+
+/** A put_create at a slot below the published checkpoint vector. */
+const ErrSlotRetired = errors.new("bumbledb-log slotRetired: the slot is retired")
+
 /** The vendor channel: I/O and store infrastructure failures. */
 const ErrStore = errors.new("bumbledb-log store failure")
 
@@ -63,9 +85,11 @@ type RefusalCause =
 	| { readonly kind: "EmptyInterval"; readonly relation: string; readonly row: number; readonly field: string }
 	| { readonly kind: "IntervalOverflow"; readonly relation: string; readonly row: number; readonly field: string }
 	| { readonly kind: "TrailingBytes"; readonly bytes: number }
-	| { readonly kind: "ManifestShape" }
+	| { readonly kind: "DigestWidth" }
+	| { readonly kind: "Arity"; readonly op: number; readonly relation: string; readonly row: number }
+	| { readonly kind: "Malformed"; readonly at: number }
+	| { readonly kind: "Overflow" }
 	| { readonly kind: "ManifestVersion"; readonly version: number }
-	| { readonly kind: "CheckpointShape" }
 	| { readonly kind: "CheckpointBraids"; readonly carried: readonly string[]; readonly derived: readonly string[] }
 	| { readonly kind: "CheckpointDigest"; readonly expected: string; readonly computed: string }
 	| { readonly kind: "NoOpSlot"; readonly braid: Braid; readonly slot: Generation; readonly writer: bigint }
@@ -92,9 +116,39 @@ interface ContentionData {
 	readonly cause: ContentionCause
 }
 
+type AmbiguousVerb = "create" | "swap"
+
+interface AmbiguousData {
+	readonly verb: AmbiguousVerb
+	readonly key: StoreKey
+}
+
+interface OverWidthData {
+	readonly requested: bigint
+}
+
+interface ExhaustedData {
+	readonly relation: number
+	readonly field: number
+}
+
+interface SlotRetiredData {
+	readonly braid: Braid
+	readonly slot: Generation
+}
+
+/** The id-lease algebra's refusal arms: OverWidth | Exhausted. */
+type LeaseRefusal =
+	| { readonly kind: "OverWidth"; readonly requested: bigint }
+	| { readonly kind: "Exhausted"; readonly relation: number; readonly field: number }
+
 const refusalData = new WeakMap<Error, RefusalCause>()
 const chainData = new WeakMap<Error, ChainMismatchData>()
 const contentionData = new WeakMap<Error, ContentionData>()
+const ambiguousData = new WeakMap<Error, AmbiguousData>()
+const overWidthData = new WeakMap<Error, OverWidthData>()
+const exhaustedData = new WeakMap<Error, ExhaustedData>()
+const slotRetiredData = new WeakMap<Error, SlotRetiredData>()
 
 function refuse(cause: RefusalCause, detail: string): never {
 	const error = errors.wrap(ErrRefused, detail)
@@ -114,6 +168,38 @@ function throwContention(data: ContentionData, detail: string): never {
 	throw error
 }
 
+function refuseManifestMissing(detail: string): never {
+	throw errors.wrap(ErrManifestMissing, detail)
+}
+
+function isManifestMissing(error: unknown): boolean {
+	return error instanceof Error && errors.is(error, ErrManifestMissing)
+}
+
+function throwAmbiguous(data: AmbiguousData, detail: string): never {
+	const error = errors.wrap(ErrAmbiguous, detail)
+	ambiguousData.set(error, data)
+	throw error
+}
+
+function refuseOverWidth(data: OverWidthData, detail: string): never {
+	const error = errors.wrap(ErrOverWidth, detail)
+	overWidthData.set(error, data)
+	throw error
+}
+
+function refuseExhausted(data: ExhaustedData, detail: string): never {
+	const error = errors.wrap(ErrExhausted, detail)
+	exhaustedData.set(error, data)
+	throw error
+}
+
+function refuseSlotRetired(data: SlotRetiredData, detail: string): never {
+	const error = errors.wrap(ErrSlotRetired, detail)
+	slotRetiredData.set(error, data)
+	throw error
+}
+
 function refusalOf(error: Error): RefusalCause | undefined {
 	return refusalData.get(error)
 }
@@ -126,6 +212,22 @@ function contentionOf(error: Error): ContentionData | undefined {
 	return contentionData.get(error)
 }
 
+function ambiguousOf(error: Error): AmbiguousData | undefined {
+	return ambiguousData.get(error)
+}
+
+function overWidthOf(error: Error): OverWidthData | undefined {
+	return overWidthData.get(error)
+}
+
+function exhaustedOf(error: Error): ExhaustedData | undefined {
+	return exhaustedData.get(error)
+}
+
+function slotRetiredOf(error: Error): SlotRetiredData | undefined {
+	return slotRetiredData.get(error)
+}
+
 /** Every store failure wraps the exported sentinel itself, so
  *  `errors.is(e, ErrStore)` matches by identity; the vendor error's
  *  message rides the detail verbatim. */
@@ -133,20 +235,46 @@ function wrapStore(inner: Error, detail: string): Error {
 	return errors.wrap(ErrStore, `${detail}: ${inner.message}`)
 }
 
-export type { ChainCause, ChainMismatchData, ContentionCause, ContentionData, RefusalCause }
+export type {
+	AmbiguousData,
+	AmbiguousVerb,
+	ChainCause,
+	ChainMismatchData,
+	ContentionCause,
+	ContentionData,
+	ExhaustedData,
+	LeaseRefusal,
+	OverWidthData,
+	RefusalCause,
+	SlotRetiredData
+}
 export {
+	ambiguousOf,
 	chainMismatchOf,
 	contentionOf,
+	ErrAmbiguous,
 	ErrChainMismatch,
 	ErrContention,
+	ErrExhausted,
 	ErrGapDetected,
+	ErrOverWidth,
 	ErrRefused,
 	ErrReplayDiverged,
+	ErrSlotRetired,
 	ErrSpanningCommit,
 	ErrStore,
+	exhaustedOf,
+	isManifestMissing,
+	overWidthOf,
 	refusalOf,
 	refuse,
 	refuseChain,
+	refuseExhausted,
+	refuseManifestMissing,
+	refuseOverWidth,
+	refuseSlotRetired,
+	slotRetiredOf,
+	throwAmbiguous,
 	throwContention,
 	wrapStore
 }