better-ship 0.3.2 → 0.4.1

package/dist/cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","names":[],"sources":["../src/infrastructure/cloudflare/d1-database-types.ts","../src/infrastructure/cloudflare/base-d1-repository.ts","../src/infrastructure/cloudflare/classify-d1-error.ts","../src/infrastructure/cloudflare/d1-message-store.ts","../src/infrastructure/cloudflare/d1-schema.ts","../src/infrastructure/cloudflare/d1-batch-transaction.ts","../src/infrastructure/cloudflare/d1-database-execution.ts"],"mappings":";;;;;;;KAKY,eAAe;;KAGf,KAAK,eAAe,iBAAiB,kBAAkB;;KAGvD,SAAS,eAAe,iBAAiB,KACnD,KAAK;;KAKK,KAAK,eAAe;WACrB,IAAI,KAAK;;;;;UCRH;EACf,iBAAiB,cAAc;EAC/B;;;;;;8BAOoB,iBAAiB,eAAe;qBACrB,IAAI,KAAK;EAAxC,YAA+B,IAAI,KAAK;;YAG9B,MAAM,WAAW;;YAKjB,KAAK,GAAG,mBAAmB,aAAa,YAAY,KAAK,QAAQ;;YAKjE,eAAe,WAAW;;;;;;;;wBCVtB,gBAAgB,gBAAgB,qBAAyB;;;;qBCT5D,eAAe,eAAe,uBACjC,iBAAiB,mBACd;EAEL,MAAM,WAAW,YAAY;EAc7B,cAAc,QAAQ,cAAc,SAAS;;;;;qBC1BxC,qDAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAjB;;;;;;;;;;;;;;;;qBAYA,iDAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBCPb,mBAAmB,eAAe,0BAA0B,aACvE,KAAK;mBAEwB;EAA7B,YAA6B,IAAI,KAAK;EAEhC,YAAY,GAAG,OAAO,IAAI,KAAK,YAAY,QAAQ,KAAK,QAAQ;;;;;wBCblD,gBAAgB,GACpC,mBACA,YAAY,YAAY,KACvB,QAAQ"}

package/dist/cloudflare.js

@@ -0,0 +1,169 @@
+import { m as AppError, p as DatabaseError } from "./core-MjwyZJ4i.js";
+import { i as MessageAlreadyProcessedError } from "./application-rpZoTfzU.js";
+import { i as stageD1Statement, n as eventCollector, r as runWithUnitOfWorkContext, t as collectD1Statements } from "./unit-of-work-context-BLNj72v0.js";
+import { DrizzleQueryError } from "drizzle-orm/errors";
+import { eq, sql } from "drizzle-orm";
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+//#region src/infrastructure/cloudflare/classify-d1-error.ts
+const KIND_BY_CODE = /* @__PURE__ */ new Map([
+	["SQLITE_CONSTRAINT_PRIMARYKEY", "unique"],
+	["SQLITE_CONSTRAINT_UNIQUE", "unique"],
+	["SQLITE_CONSTRAINT_NOTNULL", "not_null"],
+	["SQLITE_CONSTRAINT_FOREIGNKEY", "foreign_key"],
+	["SQLITE_CONSTRAINT_CHECK", "check"]
+]);
+const KIND_BY_PROSE = [
+	["UNIQUE constraint failed", "unique"],
+	["NOT NULL constraint failed", "not_null"],
+	["FOREIGN KEY constraint failed", "foreign_key"],
+	["CHECK constraint failed", "check"]
+];
+/**
+* Recognize D1 failures and preserve the original cause. Unrecognized callback exceptions remain unchanged.
+* D1 exposes error codes and constraint locations in text, so parsing stays at this boundary.
+*/
+function classifyD1Error(cause, operation = "D1 query") {
+	if (cause instanceof AppError || cause instanceof Error && cause.name === "AbortError") return void 0;
+	const message = messagesOf(cause);
+	const kind = kindOf(message);
+	const classification = kind === void 0 ? classificationOf(message) : "terminal";
+	const code = message.match(/\b(?:SQLITE_[A-Z_]+|D1_[A-Z_]+)\b/)?.[0];
+	if (code === void 0 && classification === "unknown" && !(cause instanceof DrizzleQueryError)) return void 0;
+	const location = message.match(/constraint failed: (\w+)\.(\w+)(?=\s*(?::\s*SQLITE_|$|\n))/);
+	const check = kind === "check" ? message.match(/CHECK constraint failed: ([A-Za-z_]\w*)/) : null;
+	return new DatabaseError(operation, classification, {
+		database: "d1",
+		code,
+		kind,
+		table: location?.[1],
+		column: location?.[2],
+		constraintName: check?.[1]
+	}, { cause });
+}
+function kindOf(message) {
+	const code = message.match(/SQLITE_CONSTRAINT_\w+/)?.[0];
+	if (code !== void 0) return KIND_BY_CODE.get(code);
+	return KIND_BY_PROSE.find(([prose]) => message.includes(prose))?.[1];
+}
+function messagesOf(cause) {
+	const messages = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = cause;
+	while (current instanceof Error && !seen.has(current)) {
+		seen.add(current);
+		if (!(current instanceof DrizzleQueryError)) messages.push(current.message);
+		current = current.cause;
+	}
+	if (typeof current === "string") messages.push(current);
+	return messages.join("\n");
+}
+const TERMINAL_FAILURE = /\bSQLITE_(?:ERROR|MISMATCH|TOOBIG|FULL|AUTH|PERM|READONLY)\b|\bD1_(?:TYPE_ERROR|COLUMN_NOTFOUND)\b|no such (?:table|column|function)|syntax error|datatype mismatch|exceeded (?:timeout|its memory limit|its CPU time limit|maximum DB size)|maximum account storage limit|free tier daily row (?:read|write) limit/i;
+const TRANSIENT_FAILURE = /Network connection lost\.|Replica disconnected from primary\.|D1 DB reset because its code was updated\.|Internal error (?:while starting up|in) D1 DB storage caused object to be reset\.|Cannot resolve D1 DB due to transient issue on remote node\.|Can't read from request stream because client disconnected\./i;
+function classificationOf(message) {
+	if (TERMINAL_FAILURE.test(message)) return "terminal";
+	if (TRANSIENT_FAILURE.test(message)) return "transient";
+	return "unknown";
+}
+
+//#endregion
+//#region src/infrastructure/cloudflare/d1-database-execution.ts
+/** Execute once without retries; convert recognized D1 failures and preserve other exceptions unchanged. */
+async function executeDatabase(operation, work) {
+	try {
+		return await work();
+	} catch (cause) {
+		throw classifyD1Error(cause, operation) ?? cause;
+	}
+}
+
+//#endregion
+//#region src/infrastructure/cloudflare/base-d1-repository.ts
+/**
+* Shared plumbing for a repository that writes inside a D1 unit of work.
+* Writes are staged, never run; the boundary commits them as one batch. Reads run on `db` now.
+*/
+var BaseD1Repository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	/** Add a statement to the current D1 batch without executing it. */
+	stage(statement) {
+		stageD1Statement(statement);
+	}
+	/** Execute one read with database error conversion and no automatic retries. */
+	read(operation, query) {
+		return executeDatabase(operation, query);
+	}
+	/** Drain an aggregate's pending events into the active boundary. */
+	dispatchEvents(aggregate) {
+		const events = aggregate.collectEvents();
+		if (events.length === 0) return;
+		for (const event of events) eventCollector.emit(event);
+		aggregate.clearEvents();
+	}
+};
+
+//#endregion
+//#region src/infrastructure/cloudflare/d1-schema.ts
+/** One row per committed message. The primary key is the idempotency claim. */
+const processedMessages = sqliteTable("processed_messages", {
+	messageId: text("message_id").primaryKey(),
+	processedAt: integer("processed_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+}, (table) => [index("idx_processed_messages_processed_at").on(table.processedAt)]);
+/** Events committed with their state change, waiting for the relay to deliver them. */
+const messageOutbox = sqliteTable("message_outbox", {
+	id: text("id").primaryKey(),
+	payload: text("payload", { mode: "json" }).$type().notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+	availableAt: integer("available_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+	attempts: integer("attempts").notNull().default(0),
+	claimToken: text("claim_token"),
+	claimExpiresAt: integer("claim_expires_at", { mode: "timestamp" }),
+	publishedAt: integer("published_at", { mode: "timestamp" }),
+	failedAt: integer("failed_at", { mode: "timestamp" }),
+	lastError: text("last_error")
+}, (table) => [index("idx_message_outbox_due").on(table.availableAt, table.createdAt).where(sql`${table.publishedAt} IS NULL`), index("idx_message_outbox_claim_token").on(table.claimToken)]);
+
+//#endregion
+//#region src/infrastructure/cloudflare/d1-message-store.ts
+/** Processed messages and outbox events share one D1 batch; the primary key prevents concurrent duplicate commits. */
+var D1MessageStore = class extends BaseD1Repository {
+	async claim(messageId) {
+		if (await this.read("claim message", () => this.db.select({ messageId: processedMessages.messageId }).from(processedMessages).where(eq(processedMessages.messageId, messageId)).get()) !== void 0) throw new MessageAlreadyProcessedError(messageId);
+		this.stage(this.db.insert(processedMessages).values({ messageId }));
+	}
+	async persistEvents(events) {
+		if (events.length === 0) return;
+		this.stage(this.db.insert(messageOutbox).values(events.map((event) => ({
+			id: event.id,
+			payload: event
+		}))));
+	}
+};
+
+//#endregion
+//#region src/infrastructure/cloudflare/d1-batch-transaction.ts
+/**
+* The D1 transaction boundary: every write is staged during `work` and committed as one
+* `db.batch()`. A throw inside `work` means the batch never runs.
+*/
+var D1BatchTransaction = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async transaction(work) {
+		return runWithUnitOfWorkContext("d1", async () => {
+			const value = await work({ db: this.db });
+			const [first, ...rest] = collectD1Statements();
+			if (first !== void 0) await executeDatabase("commit unit of work", () => this.db.batch([first, ...rest]));
+			return value;
+		});
+	}
+};
+
+//#endregion
+export { BaseD1Repository, D1BatchTransaction, D1MessageStore, DatabaseError, classifyD1Error, eventCollector, executeDatabase, messageOutbox, processedMessages };
+//# sourceMappingURL=cloudflare.js.map

package/dist/cloudflare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.js","names":[],"sources":["../src/infrastructure/cloudflare/classify-d1-error.ts","../src/infrastructure/cloudflare/d1-database-execution.ts","../src/infrastructure/cloudflare/base-d1-repository.ts","../src/infrastructure/cloudflare/d1-schema.ts","../src/infrastructure/cloudflare/d1-message-store.ts","../src/infrastructure/cloudflare/d1-batch-transaction.ts"],"sourcesContent":["import { DrizzleQueryError } from 'drizzle-orm/errors'\n\nimport { AppError, DatabaseError, type D1ConstraintKind, type FailureClassification } from '@/core'\n\nconst KIND_BY_CODE: ReadonlyMap<string, D1ConstraintKind> = new Map([\n  ['SQLITE_CONSTRAINT_PRIMARYKEY', 'unique'],\n  ['SQLITE_CONSTRAINT_UNIQUE', 'unique'],\n  ['SQLITE_CONSTRAINT_NOTNULL', 'not_null'],\n  ['SQLITE_CONSTRAINT_FOREIGNKEY', 'foreign_key'],\n  ['SQLITE_CONSTRAINT_CHECK', 'check'],\n])\n\nconst KIND_BY_PROSE: ReadonlyArray<readonly [string, D1ConstraintKind]> = [\n  ['UNIQUE constraint failed', 'unique'],\n  ['NOT NULL constraint failed', 'not_null'],\n  ['FOREIGN KEY constraint failed', 'foreign_key'],\n  ['CHECK constraint failed', 'check'],\n]\n\n/**\n * Recognize D1 failures and preserve the original cause. Unrecognized callback exceptions remain unchanged.\n * D1 exposes error codes and constraint locations in text, so parsing stays at this boundary.\n */\nexport function classifyD1Error(cause: unknown, operation = 'D1 query'): DatabaseError | undefined {\n  if (cause instanceof AppError || (cause instanceof Error && cause.name === 'AbortError'))\n    return undefined\n  const message = messagesOf(cause)\n  const kind = kindOf(message)\n  const classification = kind === undefined ? classificationOf(message) : 'terminal'\n  const code = message.match(/\\b(?:SQLITE_[A-Z_]+|D1_[A-Z_]+)\\b/)?.[0]\n  if (code === undefined && classification === 'unknown' && !(cause instanceof DrizzleQueryError))\n    return undefined\n  // A composite unique constraint must not be mistaken for the processed-message primary key.\n  const location = message.match(/constraint failed: (\\w+)\\.(\\w+)(?=\\s*(?::\\s*SQLITE_|$|\\n))/)\n  const check = kind === 'check' ? message.match(/CHECK constraint failed: ([A-Za-z_]\\w*)/) : null\n  return new DatabaseError(\n    operation,\n    classification,\n    {\n      database: 'd1',\n      code,\n      kind,\n      table: location?.[1],\n      column: location?.[2],\n      constraintName: check?.[1],\n    },\n    { cause },\n  )\n}\n\nfunction kindOf(message: string): D1ConstraintKind | undefined {\n  const code = message.match(/SQLITE_CONSTRAINT_\\w+/)?.[0]\n  if (code !== undefined) return KIND_BY_CODE.get(code)\n  return KIND_BY_PROSE.find(([prose]) => message.includes(prose))?.[1]\n}\n\n// Drizzle query messages contain SQL and values, which are not evidence about the database failure.\nfunction messagesOf(cause: unknown): string {\n  const messages: string[] = []\n  const seen = new Set<unknown>()\n  let current = cause\n  while (current instanceof Error && !seen.has(current)) {\n    seen.add(current)\n    if (!(current instanceof DrizzleQueryError)) messages.push(current.message)\n    current = current.cause\n  }\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- D1 can expose a raw string cause; this boundary accepts only that representation.\n  if (typeof current === 'string') messages.push(current)\n  return messages.join('\\n')\n}\n\n// Cloudflare documents these conditions separately from transient storage resets.\nconst TERMINAL_FAILURE =\n  /\\bSQLITE_(?:ERROR|MISMATCH|TOOBIG|FULL|AUTH|PERM|READONLY)\\b|\\bD1_(?:TYPE_ERROR|COLUMN_NOTFOUND)\\b|no such (?:table|column|function)|syntax error|datatype mismatch|exceeded (?:timeout|its memory limit|its CPU time limit|maximum DB size)|maximum account storage limit|free tier daily row (?:read|write) limit/i\nconst TRANSIENT_FAILURE =\n  /Network connection lost\\.|Replica disconnected from primary\\.|D1 DB reset because its code was updated\\.|Internal error (?:while starting up|in) D1 DB storage caused object to be reset\\.|Cannot resolve D1 DB due to transient issue on remote node\\.|Can't read from request stream because client disconnected\\./i\n\nfunction classificationOf(message: string): FailureClassification {\n  if (TERMINAL_FAILURE.test(message)) return 'terminal'\n  if (TRANSIENT_FAILURE.test(message)) return 'transient'\n  return 'unknown'\n}\n","import { classifyD1Error } from './classify-d1-error.ts'\n\n/** Execute once without retries; convert recognized D1 failures and preserve other exceptions unchanged. */\nexport async function executeDatabase<T>(\n  operation: string,\n  work: () => PromiseLike<T>,\n): Promise<T> {\n  try {\n    return await work()\n  } catch (cause) {\n    throw classifyD1Error(cause, operation) ?? cause\n  }\n}\n","import type { BatchItem } from 'drizzle-orm/batch'\n\nimport type { Event } from '@/application'\n\nimport type { DrizzleSchema } from '../drizzle-schema.ts'\nimport { eventCollector, stageD1Statement } from '../unit-of-work-context.ts'\nimport { executeDatabase } from './d1-database-execution.ts'\nimport type { D1Db } from './d1-database-types.ts'\n\n/** A domain aggregate that accumulates events for the unit of work to drain. */\nexport interface AggregateEvents {\n  collectEvents(): ReadonlyArray<Event>\n  clearEvents(): void\n}\n\n/**\n * Shared plumbing for a repository that writes inside a D1 unit of work.\n * Writes are staged, never run; the boundary commits them as one batch. Reads run on `db` now.\n */\nexport abstract class BaseD1Repository<Schema extends DrizzleSchema> {\n  constructor(protected readonly db: D1Db<Schema>) {}\n\n  /** Add a statement to the current D1 batch without executing it. */\n  protected stage(statement: BatchItem<'sqlite'>): void {\n    stageD1Statement(statement)\n  }\n\n  /** Execute one read with database error conversion and no automatic retries. */\n  protected read<T>(operation: string, query: () => PromiseLike<T>): Promise<T> {\n    return executeDatabase(operation, query)\n  }\n\n  /** Drain an aggregate's pending events into the active boundary. */\n  protected dispatchEvents(aggregate: AggregateEvents): void {\n    const events = aggregate.collectEvents()\n    if (events.length === 0) return\n    for (const event of events) eventCollector.emit(event)\n    aggregate.clearEvents()\n  }\n}\n","import { sql } from 'drizzle-orm'\nimport { index, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core'\n\nimport type { Event } from '@/application'\n\n/** One row per committed message. The primary key is the idempotency claim. */\nexport const processedMessages = sqliteTable(\n  'processed_messages',\n  {\n    messageId: text('message_id').primaryKey(),\n    processedAt: integer('processed_at', { mode: 'timestamp' })\n      .notNull()\n      .$defaultFn(() => new Date()),\n  },\n  (table) => [index('idx_processed_messages_processed_at').on(table.processedAt)],\n)\n\n/** Events committed with their state change, waiting for the relay to deliver them. */\nexport const messageOutbox = sqliteTable(\n  'message_outbox',\n  {\n    id: text('id').primaryKey(),\n    payload: text('payload', { mode: 'json' }).$type<Event>().notNull(),\n    createdAt: integer('created_at', { mode: 'timestamp' })\n      .notNull()\n      .$defaultFn(() => new Date()),\n    availableAt: integer('available_at', { mode: 'timestamp' })\n      .notNull()\n      .$defaultFn(() => new Date()),\n    attempts: integer('attempts').notNull().default(0),\n    claimToken: text('claim_token'),\n    claimExpiresAt: integer('claim_expires_at', { mode: 'timestamp' }),\n    publishedAt: integer('published_at', { mode: 'timestamp' }),\n    failedAt: integer('failed_at', { mode: 'timestamp' }),\n    lastError: text('last_error'),\n  },\n  (table) => [\n    index('idx_message_outbox_due')\n      .on(table.availableAt, table.createdAt)\n      .where(sql`${table.publishedAt} IS NULL`),\n    index('idx_message_outbox_claim_token').on(table.claimToken),\n  ],\n)\n","import { eq } from 'drizzle-orm'\n\nimport {\n  MessageAlreadyProcessedError,\n  type Event,\n  type IMessageStore,\n  type MessageId,\n} from '@/application'\n\nimport type { DrizzleSchema } from '../drizzle-schema.ts'\nimport { BaseD1Repository } from './base-d1-repository.ts'\nimport { messageOutbox, processedMessages } from './d1-schema.ts'\n\n/** Processed messages and outbox events share one D1 batch; the primary key prevents concurrent duplicate commits. */\nexport class D1MessageStore<Schema extends DrizzleSchema>\n  extends BaseD1Repository<Schema>\n  implements IMessageStore\n{\n  async claim(messageId: MessageId): Promise<void> {\n    const processed = await this.read('claim message', () =>\n      this.db\n        .select({ messageId: processedMessages.messageId })\n        .from(processedMessages)\n        .where(eq(processedMessages.messageId, messageId))\n        .get(),\n    )\n    if (processed !== undefined) throw new MessageAlreadyProcessedError(messageId)\n\n    // Concurrent deliveries can pass the read; the primary key enforces the claim at commit.\n    this.stage(this.db.insert(processedMessages).values({ messageId }))\n  }\n\n  async persistEvents(events: ReadonlyArray<Event>): Promise<void> {\n    if (events.length === 0) return\n    this.stage(\n      this.db\n        .insert(messageOutbox)\n        .values(events.map((event) => ({ id: event.id, payload: event }))),\n    )\n  }\n}\n","import type { ITransaction } from '@/application'\n\nimport type { DrizzleSchema } from '../drizzle-schema.ts'\nimport { collectD1Statements, runWithUnitOfWorkContext } from '../unit-of-work-context.ts'\nimport { executeDatabase } from './d1-database-execution.ts'\nimport type { D1Db, D1Tx } from './d1-database-types.ts'\n\n/**\n * The D1 transaction boundary: every write is staged during `work` and committed as one\n * `db.batch()`. A throw inside `work` means the batch never runs.\n */\nexport class D1BatchTransaction<Schema extends DrizzleSchema> implements ITransaction<\n  D1Tx<Schema>\n> {\n  constructor(private readonly db: D1Db<Schema>) {}\n\n  async transaction<T>(work: (tx: D1Tx<Schema>) => Promise<T>): Promise<T> {\n    return runWithUnitOfWorkContext('d1', async () => {\n      const value = await work({ db: this.db })\n      const [first, ...rest] = collectD1Statements()\n      if (first !== undefined) {\n        await executeDatabase('commit unit of work', () => this.db.batch([first, ...rest]))\n      }\n      return value\n    })\n  }\n}\n"],"mappings":"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"}

package/dist/{core-D0asUCvq.js → core-MjwyZJ4i.js}

@@ -15,6 +15,22 @@ var AppError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/core/database.error.ts
+/** Classification describes the failure; callers must separately establish whether repetition is safe. */
+var DatabaseError = class extends AppError {
+	operation;
+	classification;
+	details;
+	_tag = "DatabaseError";
+	constructor(operation, classification, details, options) {
+		super(`Database operation failed: ${operation}`, options);
+		this.operation = operation;
+		this.classification = classification;
+		this.details = details;
+	}
+};
+
 //#endregion
 //#region src/core/defects.ts
 /**
@@ -163,7 +179,7 @@ function setLogSink(fn) {
 	logSink = fn;
 }
 const LOG_LEVELS = Object.values(LogLevel);
-const MAX_ERROR_CAUSE_DEPTH = 3;
+const MAX_ERROR_DEPTH = 3;
 /**
 * Diagnostics worth keeping off an error, named one by one.
 *
@@ -185,9 +201,9 @@ const KEPT_ERROR_FIELDS = [
 	"durableObjectReset"
 ];
 const serializeError = (error, depth = 0) => {
-	if (depth > MAX_ERROR_CAUSE_DEPTH) return {
+	if (depth > MAX_ERROR_DEPTH) return {
 		name: "Error",
-		message: "[cause chain truncated]"
+		message: "[error nesting truncated]"
 	};
 	const carrier = error;
 	const kept = KEPT_ERROR_FIELDS.filter((key) => carrier[key] !== void 0);
@@ -195,13 +211,17 @@ const serializeError = (error, depth = 0) => {
 		name: error.name,
 		message: error.message
 	};
-	if (depth === 0 && error.stack !== void 0) serialized.stack = error.stack;
+	if (error.stack !== void 0) serialized.stack = error.stack;
 	if (kept.length > 0) serialized.fields = Object.fromEntries(kept.map((key) => [key, carrier[key]]));
 	if (error.cause instanceof Error) serialized.cause = serializeError(error.cause, depth + 1);
 	else if (error.cause !== void 0) serialized.cause = {
 		name: "Error",
 		message: "[non-error cause]"
 	};
+	if (error instanceof AggregateError) serialized.errors = error.errors.map((failure) => failure instanceof Error ? serializeError(failure, depth + 1) : {
+		name: "NonError",
+		message: "[non-error aggregate member]"
+	});
 	return serialized;
 };
 /** Write module-scoped logs with application defaults and optional overrides. */
@@ -278,5 +298,5 @@ function createLogger(module, config) {
 }
 
 //#endregion
-export { createLogger as a, isAbortError as c, notImplemented as d, unreachable as f, consoleSink as i, isTransientTransportError as l, Logger as n, setLogSink as o, AppError as p, configureLogger as r, setLoggerErrorHook as s, LogLevel as t, shouldRetryFailure as u };
-//# sourceMappingURL=core-D0asUCvq.js.map
+export { createLogger as a, isAbortError as c, notImplemented as d, unreachable as f, consoleSink as i, isTransientTransportError as l, AppError as m, Logger as n, setLogSink as o, DatabaseError as p, configureLogger as r, setLoggerErrorHook as s, LogLevel as t, shouldRetryFailure as u };
+//# sourceMappingURL=core-MjwyZJ4i.js.map

package/dist/core-MjwyZJ4i.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-MjwyZJ4i.js","names":[],"sources":["../src/core/app-error.ts","../src/core/database.error.ts","../src/core/defects.ts","../src/core/failure-classification.ts","../src/core/transport-classification.ts","../src/core/logger.ts"],"sourcesContent":["import type { FailureClassification } from './failure-classification.ts'\n\n/**\n * The base of every expected failure. A subclass declares its tag and its classification,\n * so no boundary has to guess what kind of failure it holds. A boundary tells our errors from\n * raw throws with `instanceof AppError`; a value that fails it was never judged.\n *\n * A `readonly` field with a literal initializer keeps the literal type, so\n * `readonly _tag = 'StoreUnavailable'` is enough for `Result` unions and `matchError`.\n */\nexport abstract class AppError extends Error {\n  abstract readonly _tag: string\n  abstract readonly classification: FailureClassification\n\n  override get name(): string {\n    return this._tag\n  }\n}\n","import { AppError } from './app-error.ts'\nimport type { FailureClassification } from './failure-classification.ts'\n\n/** SQLite reports these constraint categories through D1. */\nexport type D1ConstraintKind = 'unique' | 'not_null' | 'foreign_key' | 'check'\n\n/** Database evidence for callers that interpret a specific code or constraint. */\nexport type DatabaseFailure =\n  | {\n      readonly database: 'd1'\n      readonly code: string | undefined\n      readonly kind: D1ConstraintKind | undefined\n      readonly table: string | undefined\n      readonly column: string | undefined\n      readonly constraintName: string | undefined\n    }\n  | {\n      readonly database: 'postgres'\n      readonly code: string | undefined\n      readonly table_name: string | undefined\n      readonly column_name: string | undefined\n      readonly constraint_name: string | undefined\n    }\n\n/** Classification describes the failure; callers must separately establish whether repetition is safe. */\nexport class DatabaseError extends AppError {\n  readonly _tag = 'DatabaseError'\n\n  constructor(\n    readonly operation: string,\n    readonly classification: FailureClassification,\n    readonly details: DatabaseFailure,\n    options: { readonly cause: unknown },\n  ) {\n    super(`Database operation failed: ${operation}`, options)\n  }\n}\n","import { panic } from 'better-result'\n\n/**\n * Mark a line the types say cannot run. A union member without a branch stops compilation here.\n *\n * @throws Panic when a value outside the union arrives at runtime.\n */\nexport function unreachable(value: never): never {\n  return panic(`Unreachable: ${String(value)}`)\n}\n\n/**\n * Mark a body that is not written yet. A defect, not an expected failure.\n *\n * @param what - The behavior the body will provide, such as `invoice export`.\n * @throws Panic always.\n */\nexport function notImplemented(what: string): never {\n  return panic(`Not implemented: ${what}`)\n}\n","/**\n * What one failure is, before any policy decides what to do about it.\n *\n * `transient`: the world may differ on the next attempt. `terminal`: repeating gives the\n * same answer. `unknown`: nobody judged this error, so it came from outside unwrapped.\n */\nexport type FailureClassification = 'transient' | 'terminal' | 'unknown'\n\n/**\n * Who is asking to repeat the work.\n *\n * An immediate owner holds a caller and a socket open. A durable owner already stored the\n * work, so it can afford to try again on a failure nobody classified.\n */\nexport type RetryOwner = 'immediate' | 'durable'\n\n/** Decide whether one retry owner may repeat a failed operation. */\nexport function shouldRetryFailure(args: {\n  readonly classification: FailureClassification\n  readonly repeatSafe: boolean\n  readonly owner: RetryOwner\n}): boolean {\n  if (!args.repeatSafe) return false\n  if (args.classification === 'transient') return true\n  if (args.classification === 'terminal') return false\n  return args.owner === 'durable'\n}\n","/**\n * Messages that the platform-neutral transports raise for a failure that may pass.\n *\n * A boundary that knows its own runtime adds its own patterns before these.\n */\nconst TRANSIENT_TRANSPORT_PATTERNS = [\n  /network/,\n  /fetch failed/,\n  /timeout/,\n  /timed?\\s*out/,\n  /connection.*(lost|reset|refused|closed|aborted)/,\n  /econnreset/,\n  /econnrefused/,\n  /etimedout/,\n  /eai_again/,\n]\n\n/** Cancellation is a decision, not a failure to repeat. */\nexport function isAbortError(cause: unknown): boolean {\n  return cause instanceof Error && cause.name === 'AbortError'\n}\n\n/** Match known transient transport messages while excluding explicit cancellation. */\nexport function isTransientTransportError(cause: unknown): boolean {\n  if (!(cause instanceof Error) || isAbortError(cause)) return false\n  const message = cause.message.toLowerCase()\n  return TRANSIENT_TRANSPORT_PATTERNS.some((pattern) => pattern.test(message))\n}\n","/**\n * Module-scoped logging for every host.\n *\n * A logger emits one plain-data entry per log. The default sink hands it to `console` as an\n * entry object for a log service or as a colored line for a person, selected at startup.\n */\n\n/** A value a log entry may carry. Errors enter only through `Logger.error`. */\nexport type LogValue =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | ReadonlyArray<LogValue>\n  | LogFields\n\n/** Named log values. */\nexport type LogFields = { readonly [key: string]: LogValue }\n\n/**\n * The supported log severity levels, in ascending order.\n *\n * A const object, not an enum, so a parsed environment value typed `'INFO'` is a `LogLevel`.\n */\nexport const LogLevel = {\n  DEBUG: 'DEBUG',\n  INFO: 'INFO',\n  WARN: 'WARN',\n  ERROR: 'ERROR',\n} as const\nexport type LogLevel = (typeof LogLevel)[keyof typeof LogLevel]\n\n/** An error as plain data, including diagnostics, causes, and aggregate members. */\nexport type SerializedError = {\n  readonly name: string\n  readonly message: string\n  readonly stack?: string\n  readonly fields?: LogFields\n  readonly cause?: SerializedError\n  readonly errors?: ReadonlyArray<SerializedError>\n}\n\n/** One log, as the sink receives it. Plain data, safe to stringify. */\nexport type LogEntry = {\n  readonly timestamp: string\n  readonly level: LogLevel\n  readonly module: string\n  readonly message: string\n  readonly data: ReadonlyArray<LogValue>\n  /** Present on `Logger.error` entries that carried an error. */\n  readonly error?: SerializedError\n}\n\n/** The context an error log carries. */\nexport type ErrorLogContext = {\n  readonly error?: unknown\n  readonly userId?: string\n  readonly details?: LogFields\n}\n\n/** What a logger lets through: a level and everything above it, or nothing. */\nexport type LogThreshold = LogLevel | 'OFF'\n\n/** Overrides the application settings for one logger. */\nexport interface LoggerConfig {\n  readonly level?: LogThreshold\n}\n\n/** `json` writes the entry object. `pretty` writes one readable line for a person. */\nexport type LogFormat = 'json' | 'pretty'\n\n/**\n * The application settings, set once at the composition root.\n *\n * An omitted field keeps its default. An explicit `undefined` is a compile error, so the root\n * parses an environment value before passing it. The logger reads no environment itself.\n */\nexport interface LoggerSettings extends LoggerConfig {\n  readonly format?: LogFormat\n}\n\n// The production server setting, so a root that never configures still logs safely.\nconst DEFAULT_SETTINGS: Required<LoggerSettings> = {\n  level: LogLevel.INFO,\n  format: 'json',\n}\n\n// The application configures once at startup; loggers can exist before startup completes.\nlet settings = DEFAULT_SETTINGS\n\n/**\n * Set application settings, including for existing loggers. Per-logger overrides take priority.\n * Call at startup, never per request. An omitted field resets to INFO and JSON output.\n */\nexport function configureLogger(config: LoggerSettings): void {\n  settings = {\n    level: config.level ?? DEFAULT_SETTINGS.level,\n    format: config.format ?? DEFAULT_SETTINGS.format,\n  }\n}\n\n/** The error data sent to the configured error hook. */\nexport interface ErrorCaptureEntry {\n  readonly error: unknown\n  readonly distinctId: string | undefined\n  readonly context: LogFields\n}\n\n/** A function that forwards one logged error to an error service. */\nexport type LoggerErrorHook = (entry: ErrorCaptureEntry) => void\n\n/** Where every log entry goes. */\nexport type LogSink = (entry: LogEntry) => void\n\nlet errorHook: LoggerErrorHook | null = null\n\n/**\n * Register the function that receives each logged error.\n *\n * Set once at the process entry point. A later call replaces the earlier hook.\n */\nexport function setLoggerErrorHook(fn: LoggerErrorHook): void {\n  errorHook = fn\n}\n\n// One console method per level, so a host that filters by method can tell them apart.\nconst CONSOLE_METHOD = {\n  [LogLevel.DEBUG]: 'debug',\n  [LogLevel.INFO]: 'info',\n  [LogLevel.WARN]: 'warn',\n  [LogLevel.ERROR]: 'error',\n} as const satisfies Record<LogLevel, 'debug' | 'info' | 'warn' | 'error'>\n\n// Built from the code point so no raw control character sits in the source.\nconst ESC = String.fromCharCode(27)\nconst ANSI_RESET = `${ESC}[0m`\nconst ANSI_GRAY = `${ESC}[90m`\nconst ANSI_BLUE = `${ESC}[34m`\n\n// Severity reads at a glance: quiet levels stay dim, and an error is the only bold line.\nconst LEVEL_ANSI = {\n  DEBUG: `${ESC}[2;36m`,\n  INFO: ANSI_BLUE,\n  WARN: `${ESC}[33m`,\n  ERROR: `${ESC}[1;31m`,\n} satisfies Record<LogLevel, string>\n\nfunction prettyLine(entry: LogEntry): string {\n  // Node prints debug and info exactly like log, so the level must be in the text too.\n  const level = `[${entry.level}]`\n  const module = `[${entry.module}]`\n  // A browser console colors by method on its own; a terminal needs ANSI to do the same.\n  if ('window' in globalThis) return `${entry.timestamp} ${level} ${module} ${entry.message}`\n  const timestamp = `${ANSI_GRAY}${entry.timestamp}${ANSI_RESET}`\n  const coloredLevel = `${LEVEL_ANSI[entry.level]}${level}${ANSI_RESET}`\n  const coloredModule = `${ANSI_BLUE}${module}${ANSI_RESET}`\n  return `${timestamp} ${coloredLevel} ${coloredModule} ${entry.message}`\n}\n\n/**\n * JSON format writes the entry object. Pretty format writes one line, then the data,\n * the error, and the stack as separate console arguments.\n */\nexport const consoleSink: LogSink = (entry) => {\n  // Resolved per call, so a console replaced after import still receives the output.\n  const write = console[CONSOLE_METHOD[entry.level]]\n  if (settings.format === 'json') {\n    write(entry)\n    return\n  }\n  const line = prettyLine(entry)\n  if (entry.error === undefined) {\n    write(line, ...entry.data)\n    return\n  }\n  // A stack inside an object prints as one quoted string; as its own argument it prints as lines.\n  const { stack, ...error } = entry.error\n  if (stack === undefined) write(line, ...entry.data, error)\n  else write(line, ...entry.data, error, `\\n${stack}`)\n}\n\nlet logSink: LogSink = consoleSink\n\n/**\n * Send every log entry somewhere other than `console`.\n *\n * Set once at the process entry point, never per module. A logger is created\n * by name and nothing else, so its destination is a fact about the process.\n */\nexport function setLogSink(fn: LogSink): void {\n  logSink = fn\n}\n\nconst LOG_LEVELS = Object.values(LogLevel)\nconst MAX_ERROR_DEPTH = 3\n\n/**\n * Diagnostics worth keeping off an error, named one by one.\n *\n * An allowlist rather than every own property: an error raised by a library we\n * do not control may hang a request or a user payload off itself, and a log is\n * the wrong place to discover that. `_tag` and `classification` are what every `AppError`\n * declares. `remote` and the three flags after it are the ones workerd sets itself.\n */\nconst KEPT_ERROR_FIELDS = [\n  '_tag',\n  'classification',\n  'code',\n  'operation',\n  'status',\n  'statusCode',\n  'remote',\n  'retryable',\n  'overloaded',\n  'durableObjectReset',\n] as const\n\ntype ErrorDiagnostics = Error & { readonly [K in (typeof KEPT_ERROR_FIELDS)[number]]?: LogValue }\n\ntype MutableSerializedError = { -readonly [K in keyof SerializedError]: SerializedError[K] }\n\nconst serializeError = (error: Error, depth = 0): SerializedError => {\n  if (depth > MAX_ERROR_DEPTH) return { name: 'Error', message: '[error nesting truncated]' }\n\n  // Every field is optional, so an `Error` is already one of these.\n  const carrier: ErrorDiagnostics = error\n  const kept = KEPT_ERROR_FIELDS.filter((key) => carrier[key] !== undefined)\n  const serialized: MutableSerializedError = { name: error.name, message: error.message }\n  if (error.stack !== undefined) serialized.stack = error.stack\n  if (kept.length > 0)\n    serialized.fields = Object.fromEntries(kept.map((key) => [key, carrier[key]]))\n  if (error.cause instanceof Error) serialized.cause = serializeError(error.cause, depth + 1)\n  else if (error.cause !== undefined)\n    serialized.cause = { name: 'Error', message: '[non-error cause]' }\n  if (error instanceof AggregateError) {\n    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- AggregateError accepts arbitrary values; instanceof Error validates each member.\n    serialized.errors = error.errors.map((failure: unknown) =>\n      failure instanceof Error\n        ? serializeError(failure, depth + 1)\n        : { name: 'NonError', message: '[non-error aggregate member]' },\n    )\n  }\n  return serialized\n}\n\n/** Write module-scoped logs with application defaults and optional overrides. */\nexport class Logger {\n  private readonly config: LoggerConfig\n\n  /** Create a logger for one module. */\n  constructor(\n    private readonly module: string,\n    overrideConfig?: LoggerConfig,\n  ) {\n    this.config = { ...overrideConfig }\n  }\n\n  private log(\n    level: LogLevel,\n    message: string,\n    data: ReadonlyArray<LogValue>,\n    error?: SerializedError,\n  ): void {\n    const threshold = this.config.level ?? settings.level\n    if (threshold === 'OFF') return\n    if (LOG_LEVELS.indexOf(level) < LOG_LEVELS.indexOf(threshold)) return\n\n    const entry = { timestamp: new Date().toISOString(), level, module: this.module, message, data }\n    logSink(error === undefined ? entry : { ...entry, error })\n  }\n\n  /** Write a debug log. */\n  debug(message: string, ...values: ReadonlyArray<LogValue>): void {\n    this.log(LogLevel.DEBUG, message, values)\n  }\n\n  /** Write an information log. */\n  info(message: string, ...values: ReadonlyArray<LogValue>): void {\n    this.log(LogLevel.INFO, message, values)\n  }\n\n  /** Write a warning log. */\n  warn(message: string, ...values: ReadonlyArray<LogValue>): void {\n    this.log(LogLevel.WARN, message, values)\n  }\n\n  /**\n   * Write an error log and send the error to the configured hook.\n   *\n   * The details say which call this was, and the error says what went wrong\n   * inside it. The entry carries the details as data and the error beside them.\n   */\n  error(message: string, context: ErrorLogContext = {}): void {\n    const details = context.details ?? {}\n    const thrown = context.error\n    let error: SerializedError | undefined\n    if (thrown instanceof Error) {\n      error = serializeError(thrown)\n    } else if (thrown !== undefined) {\n      // Not an `Error`, so there is no name or stack to keep, only its JSON form.\n      let json: string\n      try {\n        json = JSON.stringify(thrown)\n      } catch {\n        json = '[non-serializable error]'\n      }\n      error = { name: 'NonError', message: json }\n    }\n    this.log(LogLevel.ERROR, message, context.details === undefined ? [] : [details], error)\n\n    if (errorHook !== null && thrown !== undefined) {\n      errorHook({ error: thrown, distinctId: context.userId, context: details })\n    }\n  }\n}\n\n/** Create a logger for one module. */\nexport function createLogger(module: string, config?: LoggerConfig): Logger {\n  return new Logger(module, config)\n}\n"],"mappings":"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"}

package/dist/core.d.ts

@@ -1,2 +1,2 @@
-import { C as unreachable, D as shouldRetryFailure, E as RetryOwner, S as notImplemented, T as FailureClassification, _ as createLogger, a as LogFormat, b as isAbortError, c as LogThreshold, d as LoggerConfig, f as LoggerErrorHook, g as consoleSink, h as configureLogger, i as LogFields, l as LogValue, m as SerializedError, n as ErrorLogContext, o as LogLevel, p as LoggerSettings, r as LogEntry, s as LogSink, t as ErrorCaptureEntry, u as Logger, v as setLogSink, w as AppError, x as isTransientTransportError, y as setLoggerErrorHook } from "./index-eL4vb02m.js";
-export { AppError, type ErrorCaptureEntry, type ErrorLogContext, type FailureClassification, type LogEntry, type LogFields, type LogFormat, LogLevel, type LogSink, type LogThreshold, type LogValue, Logger, type LoggerConfig, type LoggerErrorHook, type LoggerSettings, type RetryOwner, type SerializedError, configureLogger, consoleSink, createLogger, isAbortError, isTransientTransportError, notImplemented, setLogSink, setLoggerErrorHook, shouldRetryFailure, unreachable };
+import { A as shouldRetryFailure, C as unreachable, D as AppError, E as DatabaseFailure, O as FailureClassification, S as notImplemented, T as DatabaseError, _ as createLogger, a as LogFormat, b as isAbortError, c as LogThreshold, d as LoggerConfig, f as LoggerErrorHook, g as consoleSink, h as configureLogger, i as LogFields, k as RetryOwner, l as LogValue, m as SerializedError, n as ErrorLogContext, o as LogLevel, p as LoggerSettings, r as LogEntry, s as LogSink, t as ErrorCaptureEntry, u as Logger, v as setLogSink, w as D1ConstraintKind, x as isTransientTransportError, y as setLoggerErrorHook } from "./index-ToddX0m3.js";
+export { AppError, type D1ConstraintKind, DatabaseError, type DatabaseFailure, type ErrorCaptureEntry, type ErrorLogContext, type FailureClassification, type LogEntry, type LogFields, type LogFormat, LogLevel, type LogSink, type LogThreshold, type LogValue, Logger, type LoggerConfig, type LoggerErrorHook, type LoggerSettings, type RetryOwner, type SerializedError, configureLogger, consoleSink, createLogger, isAbortError, isTransientTransportError, notImplemented, setLogSink, setLoggerErrorHook, shouldRetryFailure, unreachable };

package/dist/core.js

@@ -1,3 +1,3 @@
-import { a as createLogger, c as isAbortError, d as notImplemented, f as unreachable, i as consoleSink, l as isTransientTransportError, n as Logger, o as setLogSink, p as AppError, r as configureLogger, s as setLoggerErrorHook, t as LogLevel, u as shouldRetryFailure } from "./core-D0asUCvq.js";
+import { a as createLogger, c as isAbortError, d as notImplemented, f as unreachable, i as consoleSink, l as isTransientTransportError, m as AppError, n as Logger, o as setLogSink, p as DatabaseError, r as configureLogger, s as setLoggerErrorHook, t as LogLevel, u as shouldRetryFailure } from "./core-MjwyZJ4i.js";
 
-export { AppError, LogLevel, Logger, configureLogger, consoleSink, createLogger, isAbortError, isTransientTransportError, notImplemented, setLogSink, setLoggerErrorHook, shouldRetryFailure, unreachable };
+export { AppError, DatabaseError, LogLevel, Logger, configureLogger, consoleSink, createLogger, isAbortError, isTransientTransportError, notImplemented, setLogSink, setLoggerErrorHook, shouldRetryFailure, unreachable };

package/dist/index-BN_tjxME.d.ts

@@ -0,0 +1,200 @@
+import { D as AppError } from "./index-ToddX0m3.js";
+//#region src/application/messages.d.ts
+/**
+ * The identity of a command or event. Receipts and the outbox are keyed by it.
+ *
+ * Internal messages use UUID v7, so receipts sort by creation. External messages use the
+ * provider's own key, `stripe:event:evt_123`, so a redelivered webhook is a duplicate by
+ * construction. The app parses and generates ids; this package only carries them.
+ */
+type MessageId = string;
+/** An action to perform. One handler, returns a value. The product adds its payload. */
+type Command<Name extends string = string> = {
+  readonly type: 'command';
+  readonly name: Name;
+  readonly id: MessageId;
+};
+/** A request for data. One handler, returns a value. No id: nothing claims a read. */
+type Query<Name extends string = string> = {
+  readonly type: 'query';
+  readonly name: Name;
+};
+/** A fact that happened. Zero or more subscribers, returns nothing. The product adds its payload. */
+type Event<Name extends string = string> = {
+  readonly type: 'event';
+  readonly name: Name;
+  readonly id: MessageId;
+};
+/** The routing fields the bus reads. `type` selects the table, `name` selects the slot. */
+type Message = Command | Event | Query;
+//#endregion
+//#region src/application/handlers.d.ts
+/**
+ * Handles one command with the dependency container and returns the caller's value.
+ * A handler that writes inside a transaction opens the unit of work itself. Failures throw.
+ */
+type CommandHandler<TCommand extends Command, Deps, Value> = (command: TCommand, deps: Deps) => Promise<Value>;
+/**
+ * Handles one query with the read-only view of the container.
+ * The view is a type over the same object, so a query cannot name a write capability.
+ */
+type QueryHandler<TQuery extends Query, QueryDeps, Value> = (query: TQuery, deps: QueryDeps) => Promise<Value>;
+/** Completes one subscriber's work for an event. Failures throw. */
+type EventHandler<TEvent extends Event, Deps> = (event: TEvent, deps: Deps) => Promise<void>;
+//#endregion
+//#region src/application/message-store.d.ts
+/**
+ * Stores processed messages and outgoing events in the same transaction as application writes.
+ * One adapter per database, built on the boundary like every other repository.
+ */
+interface IMessageStore {
+  /** Record this message in the transaction; reject an existing record with `MessageAlreadyProcessedError`. */
+  claim(messageId: MessageId): Promise<void>;
+  /** Write the events to the outbox, inside the same boundary as the state change. */
+  persistEvents(events: ReadonlyArray<Event>): Promise<void>;
+}
+//#endregion
+//#region src/application/registry.d.ts
+/** One slot per command. `unknown` keeps the slot covariant; `MessageResult` recovers the value. */
+type CommandRegistry<TCommand extends Command, Deps> = { readonly [M in TCommand as M['name']]: CommandHandler<M, Deps, unknown>; };
+/** One slot per query, typed with the read-only view of the container. */
+type QueryRegistry<TQuery extends Query, QueryDeps> = { readonly [M in TQuery as M['name']]: QueryHandler<M, QueryDeps, unknown>; };
+/**
+ * Zero or more subscribers per event. Annotate the object with this type rather than
+ * `satisfies`, so an event with no subscribers is still a message the bus accepts.
+ */
+type EventRegistry<TEvent extends Event, Deps> = { readonly [M in TEvent as M['name']]?: ReadonlyArray<EventHandler<M, Deps>>; };
+/**
+ * The app's three tables. `satisfies MessageRegistry<AppMessage, AppDeps, AppQueryDeps>`
+ * makes a missing handler a compile error. `Deps extends QueryDeps` is checked here, the one
+ * place both types meet: the read view must be a subset of the container.
+ */
+type MessageRegistry<TMessage extends Message, Deps extends QueryDeps, QueryDeps> = {
+  readonly commands: CommandRegistry<Extract<TMessage, Command>, Deps>;
+  readonly queries: QueryRegistry<Extract<TMessage, Query>, QueryDeps>;
+  readonly events: EventRegistry<Extract<TMessage, Event>, Deps>;
+};
+type Slot<Deps> = {
+  handle(message: Message, deps: Deps): Promise<unknown>;
+}['handle'];
+type Subscription<Deps> = {
+  handle(event: Event, deps: Deps): Promise<void>;
+}['handle'];
+/**
+ * The registry as the bus routes it: each table keyed by name. The app's names are unknown
+ * inside the package, so this is what a runtime string can index.
+ */
+type Handlers<Deps> = {
+  readonly commands: Readonly<Record<string, Slot<Deps>>>;
+  readonly queries: Readonly<Record<string, Slot<Deps>>>;
+  readonly events: Readonly<Partial<Record<string, ReadonlyArray<Subscription<Deps>>>>>;
+};
+type SlotMessage<TSlots> = Parameters<Extract<TSlots[keyof TSlots], Slot<never>>>[0];
+type SubscriptionMessage<TSlots> = NonNullable<TSlots[keyof TSlots]> extends ReadonlyArray<infer TSubscription> ? Parameters<Extract<TSubscription, Subscription<never>>>[0] : never;
+/** The messages a registry has a slot for, read off each slot's first parameter. */
+type RegistryMessage<TRegistry extends Handlers<never>> = SlotMessage<TRegistry['commands']> | SlotMessage<TRegistry['queries']> | SubscriptionMessage<TRegistry['events']>;
+type SlotValue<TSlots, TName extends string> = TName extends keyof TSlots ? Awaited<ReturnType<Extract<TSlots[TName], Slot<never>>>> : never;
+/** The value `bus.handle(message)` resolves to: the slot's own return type, or void for an event. */
+type MessageResult<TMessage extends Message, TRegistry extends Handlers<never>> = TMessage extends Command ? SlotValue<TRegistry['commands'], TMessage['name']> : TMessage extends Query ? SlotValue<TRegistry['queries'], TMessage['name']> : void;
+//#endregion
+//#region src/application/message-bus.d.ts
+/** The port an entrypoint dispatches through. `AppDeps` names this as `IMessageBus<typeof registry>`. */
+interface IMessageBus<TRegistry extends Handlers<never>> {
+  handle<TMessage extends Message & RegistryMessage<TRegistry>>(message: TMessage): Promise<MessageResult<TMessage, TRegistry>>;
+}
+/**
+ * Routes one message to its slot. The bus opens no transaction and keeps no outbox:
+ * a handler that writes opens the unit of work itself.
+ */
+declare class MessageBus<Deps, TRegistry extends Handlers<Deps>> implements IMessageBus<TRegistry> {
+  private readonly deps;
+  private readonly registry;
+  constructor(deps: Deps, registry: TRegistry);
+  /** Resolves to the handler's own value for a command or query, and to void for an event. */
+  handle<TMessage extends Message & RegistryMessage<TRegistry>>(message: TMessage): Promise<MessageResult<TMessage, TRegistry>>;
+  private dispatch;
+  private handleCommand;
+  private handleQuery;
+  /**
+   * Every subscriber runs to completion. One failure is rethrown as is. Several are thrown as
+   * one `AggregateError`. A `MessageAlreadyProcessedError` means that subscriber already committed on
+   * an earlier delivery, so it counts as delivered.
+   */
+  private handleEvent;
+}
+//#endregion
+//#region src/application/outbox-relay.d.ts
+/**
+ * Delivers committed outbox rows. The unit of work only wakes it after a commit that wrote
+ * events; the app decides what a wake is: `waitUntil`, a Durable Object alarm, nothing.
+ * The sweep is the source of truth, so a lost wake loses no events.
+ */
+interface IOutboxRelay {
+  wake(): void;
+}
+//#endregion
+//#region src/application/transaction.d.ts
+/**
+ * Supplies `Tx` to participating repositories and resolves after their writes commit. Failure rolls back or discards writes.
+ * Nested calls reject with `UnitOfWorkAlreadyActiveError` before opening another boundary.
+ * Independent concurrent calls are allowed.
+ */
+interface ITransaction<Tx> {
+  transaction<T>(work: (tx: Tx) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/application/event-collector.d.ts
+/** Records events in the current unit of work; the unit of work collects a snapshot for outbox persistence. */
+interface IEventCollector {
+  emit(event: Event): void;
+  collect(): ReadonlyArray<Event>;
+}
+//#endregion
+//#region src/application/unit-of-work.d.ts
+/**
+ * Commits the processed-message record, repository writes, and emitted events together before resolving.
+ * An existing record rejects with `MessageAlreadyProcessedError`; external effects must run through the outbox after commit.
+ * Nested calls reject with `UnitOfWorkAlreadyActiveError`; independent concurrent calls are allowed.
+ */
+interface IUnitOfWork<Repos> {
+  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>;
+}
+type UnitOfWorkDeps<Tx, Repos> = {
+  readonly transaction: ITransaction<Tx>;
+  /** The processed-messages and outbox repository for this transaction. */
+  readonly messageStore: (tx: Tx) => IMessageStore;
+  /** Repositories participate in the current transaction. */
+  readonly createRepositories: (tx: Tx) => Repos;
+  readonly eventCollector: IEventCollector;
+  readonly relay: IOutboxRelay;
+};
+/** The unit of work: the boundary, the repositories, the events. Every database call is a port. */
+declare class UnitOfWork<Tx, Repos> implements IUnitOfWork<Repos> {
+  private readonly deps;
+  constructor(deps: UnitOfWorkDeps<Tx, Repos>);
+  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/application/message-already-processed.error.d.ts
+/** The message's effects already committed. A caller can skip duplicate delivery without repeating those effects. */
+declare class MessageAlreadyProcessedError extends AppError {
+  readonly messageId: MessageId;
+  readonly _tag = "MessageAlreadyProcessedError";
+  readonly classification = "terminal";
+  constructor(messageId: MessageId, options?: {
+    readonly cause: unknown;
+  });
+  /** Recognize only the processed-message primary key; preserve other failures unchanged at the call site. */
+  static from(cause: unknown, messageId: MessageId): MessageAlreadyProcessedError | undefined;
+}
+//#endregion
+//#region src/application/unit-of-work.errors.d.ts
+/** A boundary was opened inside another. One message, one atomic scope. */
+declare class UnitOfWorkAlreadyActiveError extends AppError {
+  readonly _tag = "UnitOfWorkAlreadyActiveError";
+  readonly classification = "terminal";
+  constructor();
+}
+//#endregion
+export { Event as C, Query as E, Command as S, MessageId as T, RegistryMessage as _, UnitOfWorkDeps as a, EventHandler as b, IOutboxRelay as c, CommandRegistry as d, EventRegistry as f, QueryRegistry as g, MessageResult as h, UnitOfWork as i, IMessageBus as l, MessageRegistry as m, MessageAlreadyProcessedError as n, IEventCollector as o, Handlers as p, IUnitOfWork as r, ITransaction as s, UnitOfWorkAlreadyActiveError as t, MessageBus as u, IMessageStore as v, Message as w, QueryHandler as x, CommandHandler as y };
+//# sourceMappingURL=index-BN_tjxME.d.ts.map

package/dist/index-BN_tjxME.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BN_tjxME.d.ts","names":[],"sources":["../src/application/messages.ts","../src/application/handlers.ts","../src/application/message-store.ts","../src/application/registry.ts","../src/application/message-bus.ts","../src/application/outbox-relay.ts","../src/application/transaction.ts","../src/application/event-collector.ts","../src/application/unit-of-work.ts","../src/application/message-already-processed.error.ts","../src/application/unit-of-work.errors.ts"],"mappings":";;;;;;;;;KAOY;;KAGA,QAAQ;WACT;WACA,MAAM;WACN,IAAI;;;KAIH,MAAM;WACP;WACA,MAAM;;;KAIL,MAAM;WACP;WACA,MAAM;WACN,IAAI;;;KAIH,UAAU,UAAU,QAAQ;;;;;;;KCxB5B,eAAe,iBAAiB,SAAS,MAAM,UACzD,SAAS,UACT,MAAM,SACH,QAAQ;;;;;KAMD,aAAa,eAAe,OAAO,WAAW,UACxD,OAAO,QACP,MAAM,cACH,QAAQ;;KAGD,aAAa,eAAe,OAAO,SAAS,OAAO,QAAQ,MAAM,SAAS;;;;;;;UCfrE;;EAEf,MAAM,WAAW,YAAY;;EAE7B,cAAc,QAAQ,cAAc,SAAS;;;;;KCNnC,gBAAgB,iBAAiB,SAAS,oBAC1C,KAAK,YAAY,YAAY,eAAe,GAAG;;KAI/C,cAAc,eAAe,OAAO,yBACpC,KAAK,UAAU,YAAY,aAAa,GAAG;;;;;KAO3C,cAAc,eAAe,OAAO,oBACpC,KAAK,UAAU,aAAa,cAAc,aAAa,GAAG;;;;;;KAQ1D,gBAAgB,iBAAiB,SAAS,aAAa,WAAW;WACnE,UAAU,gBAAgB,QAAQ,UAAU,UAAU;WACtD,SAAS,cAAc,QAAQ,UAAU,QAAQ;WACjD,QAAQ,cAAc,QAAQ,UAAU,QAAQ;;KAKtD,KAAK;EAAU,OAAO,SAAS,SAAS,MAAM,OAAO;;KACrD,aAAa;EAAU,OAAO,OAAO,OAAO,MAAM,OAAO;;;;;;KAMlD,SAAS;WACV,UAAU,SAAS,eAAe,KAAK;WACvC,SAAS,SAAS,eAAe,KAAK;WACtC,QAAQ,SAAS,QAAQ,eAAe,cAAc,aAAa;;KAGzE,YAAY,UAAU,WAAW,QAAQ,aAAa,SAAS;KAE/D,oBAAoB,UACvB,YAAY,aAAa,iBAAiB,oBAAoB,iBAC1D,WAAW,QAAQ,eAAe;;KAI5B,gBAAgB,kBAAkB,mBAC1C,YAAY,yBACZ,YAAY,wBACZ,oBAAoB;KAEnB,UAAU,QAAQ,wBAAwB,oBAAoB,SAC/D,QAAQ,WAAW,QAAQ,OAAO,QAAQ;;KAIlC,cACV,iBAAiB,SACjB,kBAAkB,mBAChB,iBAAiB,UACjB,UAAU,uBAAuB,oBACjC,iBAAiB,QACf,UAAU,sBAAsB;;;;UC5DrB,YAAY,kBAAkB;EAC7C,OAAO,iBAAiB,UAAU,gBAAgB,YAChD,SAAS,WACR,QAAQ,cAAc,UAAU;;;;;;cAOxB,WAAW,MAAM,kBAAkB,SAAS,kBAAkB,YAAY;mBAElE;mBACA;EAFnB,YACmB,MAAM,MACN,UAAU;;EAIvB,OAAO,iBAAiB,UAAU,gBAAgB,YACtD,SAAS,WACR,QAAQ,cAAc,UAAU;UAM3B;UASA;UASA;;;;;;UAWM;;;;;;;;;UC5DC;EACf;;;;;;;;;UCDe,aAAa;EAC5B,YAAY,GAAG,OAAO,IAAI,OAAO,QAAQ,KAAK,QAAQ;;;;;UCHvC;EACf,KAAK,OAAO;EACZ,WAAW,cAAc;;;;;;;;;UCOV,YAAY;EAC3B,IAAI,GAAG,WAAW,WAAW,OAAO,OAAO,UAAU,QAAQ,KAAK,QAAQ;;KAGhE,eAAe,IAAI;WACpB,aAAa,aAAa;;WAE1B,eAAe,IAAI,OAAO;;WAE1B,qBAAqB,IAAI,OAAO;WAChC,gBAAgB;WAChB,OAAO;;;cAIL,WAAW,IAAI,kBAAkB,YAAY;mBAC3B;EAA7B,YAA6B,MAAM,eAAe,IAAI;EAEhD,IAAI,GAAG,WAAW,WAAW,OAAO,OAAO,UAAU,QAAQ,KAAK,QAAQ;;;;;cCzBrE,qCAAqC;WAKrC,WAAW;WAJb;WACA;EAET,YACW,WAAW,WACpB;aAAqB;;;SAMhB,KAAK,gBAAgB,WAAW,YAAY;;;;;cCdxC,qCAAqC;WACvC;WACA;EAET"}

package/dist/{index-eL4vb02m.d.ts → index-ToddX0m3.d.ts}

@@ -35,6 +35,35 @@ declare abstract class AppError extends Error {
   get name(): string;
 }
 //#endregion
+//#region src/core/database.error.d.ts
+/** SQLite reports these constraint categories through D1. */
+type D1ConstraintKind = 'unique' | 'not_null' | 'foreign_key' | 'check';
+/** Database evidence for callers that interpret a specific code or constraint. */
+type DatabaseFailure = {
+  readonly database: 'd1';
+  readonly code: string | undefined;
+  readonly kind: D1ConstraintKind | undefined;
+  readonly table: string | undefined;
+  readonly column: string | undefined;
+  readonly constraintName: string | undefined;
+} | {
+  readonly database: 'postgres';
+  readonly code: string | undefined;
+  readonly table_name: string | undefined;
+  readonly column_name: string | undefined;
+  readonly constraint_name: string | undefined;
+};
+/** Classification describes the failure; callers must separately establish whether repetition is safe. */
+declare class DatabaseError extends AppError {
+  readonly operation: string;
+  readonly classification: FailureClassification;
+  readonly details: DatabaseFailure;
+  readonly _tag = "DatabaseError";
+  constructor(operation: string, classification: FailureClassification, details: DatabaseFailure, options: {
+    readonly cause: unknown;
+  });
+}
+//#endregion
 //#region src/core/defects.d.ts
 /**
  * Mark a line the types say cannot run. A union member without a branch stops compilation here.
@@ -81,13 +110,14 @@ declare const LogLevel: {
   readonly ERROR: 'ERROR';
 };
 type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
-/** An error as plain data: name, message, stack, allowlisted fields, and the cause chain. */
+/** An error as plain data, including diagnostics, causes, and aggregate members. */
 type SerializedError = {
   readonly name: string;
   readonly message: string;
   readonly stack?: string;
   readonly fields?: LogFields;
   readonly cause?: SerializedError;
+  readonly errors?: ReadonlyArray<SerializedError>;
 };
 /** One log, as the sink receives it. Plain data, safe to stringify. */
 type LogEntry = {
@@ -179,5 +209,5 @@ declare class Logger {
 /** Create a logger for one module. */
 declare function createLogger(module: string, config?: LoggerConfig): Logger;
 //#endregion
-export { unreachable as C, shouldRetryFailure as D, RetryOwner as E, notImplemented as S, FailureClassification as T, createLogger as _, LogFormat as a, isAbortError as b, LogThreshold as c, LoggerConfig as d, LoggerErrorHook as f, consoleSink as g, configureLogger as h, LogFields as i, LogValue as l, SerializedError as m, ErrorLogContext as n, LogLevel as o, LoggerSettings as p, LogEntry as r, LogSink as s, ErrorCaptureEntry as t, Logger as u, setLogSink as v, AppError as w, isTransientTransportError as x, setLoggerErrorHook as y };
-//# sourceMappingURL=index-eL4vb02m.d.ts.map
+export { shouldRetryFailure as A, unreachable as C, AppError as D, DatabaseFailure as E, FailureClassification as O, notImplemented as S, DatabaseError as T, createLogger as _, LogFormat as a, isAbortError as b, LogThreshold as c, LoggerConfig as d, LoggerErrorHook as f, consoleSink as g, configureLogger as h, LogFields as i, RetryOwner as k, LogValue as l, SerializedError as m, ErrorLogContext as n, LogLevel as o, LoggerSettings as p, LogEntry as r, LogSink as s, ErrorCaptureEntry as t, Logger as u, setLogSink as v, D1ConstraintKind as w, isTransientTransportError as x, setLoggerErrorHook as y };
+//# sourceMappingURL=index-ToddX0m3.d.ts.map

package/dist/index-ToddX0m3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-ToddX0m3.d.ts","names":[],"sources":["../src/core/failure-classification.ts","../src/core/app-error.ts","../src/core/database.error.ts","../src/core/defects.ts","../src/core/transport-classification.ts","../src/core/logger.ts"],"mappings":";;;;;;;KAMY;;;;;;;KAQA;;iBAGI,mBAAmB;WACxB,gBAAgB;WAChB;WACA,OAAO;;;;;;;;;;;;uBCVI,iBAAiB;oBACnB;oBACA,gBAAgB;MAErB;;;;;KCVH;;KAGA;WAEG;WACA;WACA,MAAM;WACN;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;;;cAIF,sBAAsB;WAItB;WACA,gBAAgB;WAChB,SAAS;WALX;EAET,YACW,mBACA,gBAAgB,uBAChB,SAAS,iBAClB;aAAoB;;;;;;;;;;iBCzBR,YAAY;;;;;;;iBAUZ,eAAe;;;;iBCCf,aAAa;;iBAKb,0BAA0B;;;;;;;;;;KCf9B,0DAMR,cAAc,YACd;;KAGQ;YAAwB,cAAc;;;;;;;cAOrC;WACX;WACA;WACA;WACA;;KAEU,mBAAmB,uBAAuB;;KAG1C;WACD;WACA;WACA;WACA,SAAS;WACT,QAAQ;WACR,SAAS,cAAc;;;KAItB;WACD;WACA,OAAO;WACP;WACA;WACA,MAAM,cAAc;;WAEpB,QAAQ;;;KAIP;WACD;WACA;WACA,UAAU;;;KAIT,eAAe;;UAGV;WACN,QAAQ;;;KAIP;;;;;;;UAQK,uBAAuB;WAC7B,SAAS;;;;;;iBAgBJ,gBAAgB,QAAQ;;UAQvB;WACN;WACA;WACA,SAAS;;;KAIR,mBAAmB,OAAO;;KAG1B,WAAW,OAAO;;;;;;iBASd,mBAAmB,IAAI;;;;;cA0C1B,aAAa;;;;;;;iBA0BV,WAAW,IAAI;;cAyDlB;mBAKQ;mBAJF;;EAGjB,YACmB,gBACjB,iBAAiB;UAKX;;EAeR,MAAM,oBAAoB,QAAQ,cAAc;;EAKhD,KAAK,oBAAoB,QAAQ,cAAc;;EAK/C,KAAK,oBAAoB,QAAQ,cAAc;;;;;;;EAU/C,MAAM,iBAAiB,UAAS;;;iBAyBlB,aAAa,gBAAgB,SAAS,eAAe"}