@entifix/mongo 0.8.0 → 0.10.0

package/dist/outbox/relay.js

@@ -5,8 +5,17 @@ import { Context, Duration, Effect, Fiber, Result } from 'effect';
 import { MongoDatabaseTag } from '../mongo-database/mongo-database.js';
 import { recordOutboxStats } from './metrics.js';
 import { ensureOutboxIndexes, makeMongoOutbox } from './store.js';
-/** How often the sweep looks for entries the fast path did not carry. */ export const SWEEP_INTERVAL = Duration.seconds(15);
+/** How often the sweep looks for entries the fast path did not carry. */ /**
+ * What an outbox entry records as the reason its publish failed: the failure's
+ * own message, or its code when it carries none — never empty, because an
+ * operator reading a quarantined entry has nothing else to go on.
+ */ const failureText = (failure)=>failure.message === '' ? failure.code : failure.message;
+export const SWEEP_INTERVAL = Duration.seconds(15);
 /** Entries drained per pass, per database. */ export const BATCH = 100;
+/**
+ * Hears nothing. The default only so a spec can start a relay without one —
+ * a host that passes no sink has a relay nobody can watch.
+ */ export const ignoreRelayOutcome = ()=>Effect.void;
 /**
  * Publish attempts an outbox entry gets before it is quarantined, from
  * config-service.
@@ -34,29 +43,44 @@ import { ensureOutboxIndexes, makeMongoOutbox } from './store.js';
  *   skip-so-the-head-moves: an entry that can never publish must stop blocking
  *   every entry behind it forever.
  */ export const drainOutbox = (outbox, bus, options)=>Effect.gen(function*() {
+        var _options_onOutcome;
         const entries = yield* outbox.pending(BATCH);
         let sent = 0;
+        const report = (_options_onOutcome = options.onOutcome) != null ? _options_onOutcome : ignoreRelayOutcome;
         for (const entry of entries){
             const outcome = yield* Effect.result(bus.publish(entry.event));
             if (Result.isFailure(outcome)) {
+                var _options_onOutcome1;
                 const attempts = entry.attempts + 1;
                 const quarantine = attempts >= options.maxAttempts;
-                yield* outbox.recordFailure(entry, outcome.failure.message, quarantine);
+                yield* outbox.recordFailure(entry, failureText(outcome.failure), quarantine);
                 if (!quarantine) {
+                    yield* report({
+                        _tag: 'drained',
+                        database: options.database,
+                        sent
+                    });
                     return sent;
                 }
-                yield* Effect.logError('outbox entry quarantined').pipe(Effect.annotateLogs({
+                yield* ((_options_onOutcome1 = options.onOutcome) != null ? _options_onOutcome1 : ignoreRelayOutcome)({
+                    _tag: 'quarantined',
                     database: options.database,
                     eventId: entry.eventId,
                     eventName: entry.event.name,
                     attempts,
-                    lastError: outcome.failure.message
-                }));
+                    code: outcome.failure.code,
+                    reason: failureText(outcome.failure)
+                });
                 continue;
             }
             yield* outbox.markSent(entry);
             sent += 1;
         }
+        yield* report({
+            _tag: 'drained',
+            database: options.database,
+            sent
+        });
         return sent;
     });
 /**
@@ -70,18 +94,22 @@ import { ensureOutboxIndexes, makeMongoOutbox } from './store.js';
  * Stats are sampled **after** the drain, so the gauge reports what is still
  * waiting rather than what was waiting when the pass began.
  *
- * Every failure is caught and logged. This runs inside `Effect.forever`, and an
- * error that escapes ends the daemon silently — a relay that stopped is
- * indistinguishable from a relay with nothing to do.
+ * Every failure is caught and reported as `sweepFailed`. This runs inside
+ * `Effect.forever`, and an error that escapes ends the daemon silently — a
+ * relay that stopped is indistinguishable from a relay with nothing to do.
  */ export const sweepOutbox = (outbox, bus, options)=>Effect.gen(function*() {
         var _options_onStats;
         yield* drainOutbox(outbox, bus, options);
         const sink = (_options_onStats = options.onStats) != null ? _options_onStats : recordOutboxStats;
         yield* sink(options.database, (yield* outbox.stats()));
-    }).pipe(Effect.catch((error)=>Effect.logError('outbox sweep failed').pipe(Effect.annotateLogs({
+    }).pipe(Effect.catch((failure)=>{
+        var _options_onOutcome;
+        return ((_options_onOutcome = options.onOutcome) != null ? _options_onOutcome : ignoreRelayOutcome)({
+            _tag: 'sweepFailed',
             database: options.database,
-            error: String(error)
-        }))));
+            failure
+        });
+    }));
 /**
  * Start the relay for a service that owns exactly one database.
  *
@@ -106,6 +134,8 @@ import { ensureOutboxIndexes, makeMongoOutbox } from './store.js';
             database: db.databaseName
         }, (options == null ? void 0 : options.onStats) ? {
             onStats: options.onStats
+        } : {}, (options == null ? void 0 : options.onOutcome) ? {
+            onOutcome: options.onOutcome
         } : {})));
     });
 /**
@@ -135,7 +165,8 @@ import { ensureOutboxIndexes, makeMongoOutbox } from './store.js';
  * pass: a sweep visits every tenant every interval, and the index build is the
  * same request each time.
  */ export const sweepTenantOutboxes = (directory, bus, options)=>Effect.gen(function*() {
-        var _options_ensured;
+        var _options_onOutcome, _options_ensured;
+        const report = (_options_onOutcome = options.onOutcome) != null ? _options_onOutcome : ignoreRelayOutcome;
         const ensured = (_options_ensured = options.ensured) != null ? _options_ensured : new Set();
         const tenants = yield* directory.list();
         for (const { handle: db } of tenants){
@@ -147,18 +178,24 @@ import { ensureOutboxIndexes, makeMongoOutbox } from './store.js';
                 }
                 yield* sweepOutbox(makeMongoOutbox(db), bus, _extends({
                     maxAttempts: options.maxAttempts,
-                    database
+                    database,
+                    onOutcome: report
                 }, options.onStats ? {
                     onStats: options.onStats
                 } : {}));
-            }).pipe(Effect.catch((error)=>Effect.logError('draining a tenant outbox failed').pipe(Effect.annotateLogs({
+            }).pipe(Effect.catch((failure)=>report({
+                    _tag: 'sweepFailed',
                     database,
-                    error: String(error)
-                }))));
+                    failure
+                })));
         }
-    }).pipe(Effect.catch((error)=>Effect.logError('tenant outbox sweep failed').pipe(Effect.annotateLogs({
-            error: String(error)
-        }))));
+    }).pipe(Effect.catch((failure)=>{
+        var _options_onOutcome;
+        return ((_options_onOutcome = options.onOutcome) != null ? _options_onOutcome : ignoreRelayOutcome)({
+            _tag: 'sweepFailed',
+            failure
+        });
+    }));
 /**
  * Start the relay for a store with one database per organization, listed by
  * the {@link TenantDirectoryTag} the host provides.
@@ -176,6 +213,8 @@ import { ensureOutboxIndexes, makeMongoOutbox } from './store.js';
             ensured
         }, (options == null ? void 0 : options.onStats) ? {
             onStats: options.onStats
+        } : {}, (options == null ? void 0 : options.onOutcome) ? {
+            onOutcome: options.onOutcome
         } : {})));
     });
 /**
@@ -183,18 +222,20 @@ import { ensureOutboxIndexes, makeMongoOutbox } from './store.js';
  *
  * The fast path the sweep is the fallback for: an event drained here leaves as
  * soon as its transaction commits, rather than up to {@link SWEEP_INTERVAL}
- * later. Every failure is logged and swallowed — the entry is still in the
- * outbox, and the sweep will carry it.
- */ export const drainOutboxNow = (db)=>Effect.gen(function*() {
+ * later. Every failure is reported as `drainFailed` and swallowed — the entry
+ * is still in the outbox, and the sweep will carry it.
+ */ export const drainOutboxNow = (db, onOutcome = ignoreRelayOutcome)=>Effect.gen(function*() {
         const bus = yield* EventBusTag;
         const maxAttempts = yield* OutboxMaxAttempts;
         yield* drainOutbox(makeMongoOutbox(db), bus, {
             maxAttempts,
-            database: db.databaseName
+            database: db.databaseName,
+            onOutcome
         });
-    }).pipe(Effect.catch((error)=>Effect.logWarning('inline outbox drain failed').pipe(Effect.annotateLogs({
+    }).pipe(Effect.catch((failure)=>onOutcome({
+            _tag: 'drainFailed',
             database: db.databaseName,
-            error: String(error)
-        }))));
+            failure
+        })));
 
 //# sourceMappingURL=relay.js.map

package/dist/outbox/relay.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/outbox/relay.ts"],"sourcesContent":["import {\n  ShutdownRegistryTag,\n  type TenantDirectory,\n  TenantDirectoryTag,\n} from '@entifix/business';\nimport {\n  type EventBus,\n  EventBusTag,\n  type OutboxStats,\n  type TransactionOutbox,\n} from '@entifix/transactions';\nimport { Context, Duration, Effect, Fiber, Result } from 'effect';\nimport type { Db } from 'mongodb';\n\nimport { MongoDatabaseTag } from '../mongo-database/mongo-database.js';\nimport { recordOutboxStats } from './metrics.js';\nimport { ensureOutboxIndexes, makeMongoOutbox } from './store.js';\n\n/** How often the sweep looks for entries the fast path did not carry. */\nexport const SWEEP_INTERVAL = Duration.seconds(15);\n/** Entries drained per pass, per database. */\nexport const BATCH = 100;\n\n/**\n * Publish attempts an outbox entry gets before it is quarantined, from\n * config-service.\n *\n * Configuration rather than a constant because it is a genuine operational\n * tunable: raising it while a flaky broker settles is a config edit, and the\n * next sweep reads the new value. That is the opposite of a subscription's\n * `maxAttempts`, which becomes an immutable queue argument and therefore stays\n * a literal beside its declaration.\n *\n * ⚠️ **Read it with `getNumber`, never a cast.** A value of `'five'` casts to\n * `NaN`, every `attempts >= maxAttempts` comparison goes false, and nothing is\n * ever quarantined — a relay that looks healthy while its head never moves.\n */\nexport class OutboxMaxAttempts extends Context.Service<\n  OutboxMaxAttempts,\n  number\n>()('OutboxMaxAttempts') {}\n\n/** What {@link drainOutbox} needs beyond the ports it publishes through. */\nexport interface DrainOptions {\n  readonly maxAttempts: number;\n  /** The database being drained; carried so a quarantine log names it. */\n  readonly database: string;\n}\n\n/**\n * Publish one batch of pending entries, oldest first, and answer how many went.\n *\n * Two orderings are load-bearing here and neither is obvious:\n *\n * - A **still-deliverable** failure returns immediately rather than continuing.\n *   The entries behind this one keep their order relative to it, which is what\n *   stops a terminal event overtaking the `accepted` for the same transaction.\n * - A **quarantined** failure continues. That is the deliberate\n *   skip-so-the-head-moves: an entry that can never publish must stop blocking\n *   every entry behind it forever.\n */\nexport const drainOutbox = (\n  outbox: TransactionOutbox,\n  bus: EventBus,\n  options: DrainOptions,\n) =>\n  Effect.gen(function* () {\n    const entries = yield* outbox.pending(BATCH);\n    let sent = 0;\n    for (const entry of entries) {\n      const outcome = yield* Effect.result(bus.publish(entry.event));\n\n      if (Result.isFailure(outcome)) {\n        const attempts = entry.attempts + 1;\n        const quarantine = attempts >= options.maxAttempts;\n\n        yield* outbox.recordFailure(entry, outcome.failure.message, quarantine);\n\n        if (!quarantine) {\n          return sent;\n        }\n\n        yield* Effect.logError('outbox entry quarantined').pipe(\n          Effect.annotateLogs({\n            database: options.database,\n            eventId: entry.eventId,\n            eventName: entry.event.name,\n            attempts,\n            lastError: outcome.failure.message,\n          }),\n        );\n        continue;\n      }\n\n      yield* outbox.markSent(entry);\n      sent += 1;\n    }\n    return sent;\n  });\n\n/**\n * Sample a sweep's depth and age.\n *\n * Defaults to {@link recordOutboxStats}, and a caller overrides it only to\n * assert what was sampled. There is no \"no sink\" option on purpose: an outbox\n * whose depth nothing reports is the failure the gauges exist to make visible.\n */\nexport type OutboxStatsSink = (\n  database: string,\n  stats: OutboxStats,\n) => Effect.Effect<void>;\n\n/**\n * Drain the one database this service owns, then sample its depth.\n *\n * The single-database counterpart to `startTenantOutboxRelay`. A\n * platform-plane store is one named database, so there is nothing to enumerate\n * and `listDatabases` — which needs a `MongoClient` and cluster-wide rights —\n * never comes into it.\n *\n * Stats are sampled **after** the drain, so the gauge reports what is still\n * waiting rather than what was waiting when the pass began.\n *\n * Every failure is caught and logged. This runs inside `Effect.forever`, and an\n * error that escapes ends the daemon silently — a relay that stopped is\n * indistinguishable from a relay with nothing to do.\n */\nexport const sweepOutbox = (\n  outbox: TransactionOutbox,\n  bus: EventBus,\n  options: DrainOptions & { readonly onStats?: OutboxStatsSink },\n) =>\n  Effect.gen(function* () {\n    yield* drainOutbox(outbox, bus, options);\n    const sink = options.onStats ?? recordOutboxStats;\n    yield* sink(options.database, yield* outbox.stats());\n  }).pipe(\n    Effect.catch(error =>\n      Effect.logError('outbox sweep failed').pipe(\n        Effect.annotateLogs({\n          database: options.database,\n          error: String(error),\n        }),\n      ),\n    ),\n  );\n\n/**\n * Start the relay for a service that owns exactly one database.\n *\n * ⚠️ **The shutdown hook is `flush`, not `stop-intake`, and the phase is the\n * whole point.** `AmqpEventBusLayer` registers `stop-intake` to cancel consumers\n * and drain deliveries; this runs after that, so the last sweep publishes into a\n * connection that is still open. Registered the other way round it would try to\n * publish through a channel already closing, and the entries it was holding\n * would sit until the next boot.\n *\n * The daemon is `delay |> forever`, so the first sweep is one interval away\n * rather than at boot — the write path drains inline, and a sweep racing the\n * index bootstrap on a cold database only produces noise.\n */\nexport const startOutboxRelay = (options?: {\n  readonly onStats?: OutboxStatsSink;\n}) =>\n  Effect.gen(function* () {\n    const db = yield* MongoDatabaseTag;\n    const bus = yield* EventBusTag;\n    const maxAttempts = yield* OutboxMaxAttempts;\n\n    yield* ensureOutboxIndexes(db);\n    const outbox = makeMongoOutbox(db);\n\n    yield* runRelayDaemon(\n      sweepOutbox(outbox, bus, {\n        maxAttempts,\n        database: db.databaseName,\n        ...(options?.onStats ? { onStats: options.onStats } : {}),\n      }),\n    );\n  });\n\n/**\n * Runs `sweepOnce` every {@link SWEEP_INTERVAL}, and once more on the way out.\n *\n * Interrupting the daemon before that last pass is what stops two sweeps\n * publishing the same entry; running the pass is what the hook is for — an\n * event committed a moment before shutdown would otherwise wait out the next\n * process's whole interval.\n */\nconst runRelayDaemon = (sweepOnce: Effect.Effect<void>) =>\n  Effect.gen(function* () {\n    const shutdown = yield* ShutdownRegistryTag;\n\n    const daemon = yield* Effect.forkDetach(\n      sweepOnce.pipe(Effect.delay(SWEEP_INTERVAL), Effect.forever),\n    );\n\n    yield* shutdown.register({\n      name: 'outbox-relay',\n      phase: 'flush',\n      run: Fiber.interrupt(daemon).pipe(Effect.andThen(sweepOnce)),\n    });\n  });\n\n/**\n * One pass over every organization's outbox in a per-organization store.\n *\n * ⚠️ **Each tenant is caught on its own.** A failure that recurs — an index\n * conflict on one old database, say — would otherwise abandon every tenant\n * listed after it on every pass, while the relay went on looking healthy.\n *\n * Indexes are ensured once per database per process (`ensured`), not on every\n * pass: a sweep visits every tenant every interval, and the index build is the\n * same request each time.\n */\nexport const sweepTenantOutboxes = (\n  directory: TenantDirectory<Db>,\n  bus: EventBus,\n  options: {\n    readonly maxAttempts: number;\n    readonly onStats?: OutboxStatsSink;\n    readonly ensured?: Set<string>;\n  },\n) =>\n  Effect.gen(function* () {\n    const ensured = options.ensured ?? new Set<string>();\n    const tenants = yield* directory.list();\n\n    for (const { handle: db } of tenants) {\n      const database = db.databaseName;\n      yield* Effect.gen(function* () {\n        if (!ensured.has(database)) {\n          yield* ensureOutboxIndexes(db);\n          ensured.add(database);\n        }\n        yield* sweepOutbox(makeMongoOutbox(db), bus, {\n          maxAttempts: options.maxAttempts,\n          database,\n          ...(options.onStats ? { onStats: options.onStats } : {}),\n        });\n      }).pipe(\n        Effect.catch(error =>\n          Effect.logError('draining a tenant outbox failed').pipe(\n            Effect.annotateLogs({ database, error: String(error) }),\n          ),\n        ),\n      );\n    }\n  }).pipe(\n    Effect.catch(error =>\n      Effect.logError('tenant outbox sweep failed').pipe(\n        Effect.annotateLogs({ error: String(error) }),\n      ),\n    ),\n  );\n\n/**\n * Start the relay for a store with one database per organization, listed by\n * the {@link TenantDirectoryTag} the host provides.\n *\n * The same two speeds as {@link startOutboxRelay}: the write path drains its\n * own tenant inline with {@link drainOutboxNow}, and this sweep carries\n * whatever that missed.\n */\nexport const startTenantOutboxRelay = (options?: {\n  readonly onStats?: OutboxStatsSink;\n}) =>\n  Effect.gen(function* () {\n    const directory = (yield* TenantDirectoryTag) as TenantDirectory<Db>;\n    const bus = yield* EventBusTag;\n    const maxAttempts = yield* OutboxMaxAttempts;\n    const ensured = new Set<string>();\n\n    yield* runRelayDaemon(\n      sweepTenantOutboxes(directory, bus, {\n        maxAttempts,\n        ensured,\n        ...(options?.onStats ? { onStats: options.onStats } : {}),\n      }),\n    );\n  });\n\n/**\n * Drain one database's outbox now, for a write path that has just committed.\n *\n * The fast path the sweep is the fallback for: an event drained here leaves as\n * soon as its transaction commits, rather than up to {@link SWEEP_INTERVAL}\n * later. Every failure is logged and swallowed — the entry is still in the\n * outbox, and the sweep will carry it.\n */\nexport const drainOutboxNow = (db: Db) =>\n  Effect.gen(function* () {\n    const bus = yield* EventBusTag;\n    const maxAttempts = yield* OutboxMaxAttempts;\n    yield* drainOutbox(makeMongoOutbox(db), bus, {\n      maxAttempts,\n      database: db.databaseName,\n    });\n  }).pipe(\n    Effect.catch(error =>\n      Effect.logWarning('inline outbox drain failed').pipe(\n        Effect.annotateLogs({\n          database: db.databaseName,\n          error: String(error),\n        }),\n      ),\n    ),\n  );\n"],"names":["ShutdownRegistryTag","TenantDirectoryTag","EventBusTag","Context","Duration","Effect","Fiber","Result","MongoDatabaseTag","recordOutboxStats","ensureOutboxIndexes","makeMongoOutbox","SWEEP_INTERVAL","seconds","BATCH","OutboxMaxAttempts","Service","drainOutbox","outbox","bus","options","gen","entries","pending","sent","entry","outcome","result","publish","event","isFailure","attempts","quarantine","maxAttempts","recordFailure","failure","message","logError","pipe","annotateLogs","database","eventId","eventName","name","lastError","markSent","sweepOutbox","sink","onStats","stats","catch","error","String","startOutboxRelay","db","runRelayDaemon","databaseName","sweepOnce","shutdown","daemon","forkDetach","delay","forever","register","phase","run","interrupt","andThen","sweepTenantOutboxes","directory","ensured","Set","tenants","list","handle","has","add","startTenantOutboxRelay","drainOutboxNow","logWarning"],"mappings":"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"}
+{"version":3,"sources":["../../src/outbox/relay.ts"],"sourcesContent":["import {\n  ShutdownRegistryTag,\n  type TenantDirectory,\n  TenantDirectoryTag,\n} from '@entifix/business';\nimport {\n  type EventBus,\n  EventBusTag,\n  type OutboxStats,\n  type TransactionOutbox,\n} from '@entifix/transactions';\nimport { Context, Duration, Effect, Fiber, Result } from 'effect';\nimport type { Db } from 'mongodb';\n\nimport { MongoDatabaseTag } from '../mongo-database/mongo-database.js';\nimport { recordOutboxStats } from './metrics.js';\nimport { ensureOutboxIndexes, makeMongoOutbox } from './store.js';\n\n/** How often the sweep looks for entries the fast path did not carry. */\n/**\n * What an outbox entry records as the reason its publish failed: the failure's\n * own message, or its code when it carries none — never empty, because an\n * operator reading a quarantined entry has nothing else to go on.\n */\nconst failureText = (failure: {\n  readonly message: string;\n  readonly code: string;\n}) => (failure.message === '' ? failure.code : failure.message);\n\nexport const SWEEP_INTERVAL = Duration.seconds(15);\n/** Entries drained per pass, per database. */\nexport const BATCH = 100;\n\n/**\n * What a relay pass did, for the host to log\n * ([ADR 0013](../../../../../docs/adr/0013-failures-are-typed-values-decided-at-the-shell.md)).\n *\n * The relay decides nothing about level or sink: it says what happened and the\n * fork site that started it — the slice's shell — decides how loud that is. A\n * `failure` is whatever the store or the bus failed with; a typed one carries\n * its code and category for the log line.\n */\nexport type RelayOutcome =\n  | {\n      readonly _tag: 'drained';\n      readonly database: string;\n      readonly sent: number;\n    }\n  | {\n      readonly _tag: 'quarantined';\n      readonly database: string;\n      readonly eventId: string;\n      readonly eventName: string;\n      readonly attempts: number;\n      readonly code: string;\n      readonly reason: string;\n    }\n  | {\n      readonly _tag: 'sweepFailed';\n      readonly database?: string;\n      readonly failure: unknown;\n    }\n  | {\n      readonly _tag: 'drainFailed';\n      readonly database: string;\n      readonly failure: unknown;\n    };\n\n/** Where a relay's outcomes go. The host's fork site supplies it. */\nexport type RelayOutcomeSink = (outcome: RelayOutcome) => Effect.Effect<void>;\n\n/**\n * Hears nothing. The default only so a spec can start a relay without one —\n * a host that passes no sink has a relay nobody can watch.\n */\nexport const ignoreRelayOutcome: RelayOutcomeSink = () => Effect.void;\n\n/**\n * Publish attempts an outbox entry gets before it is quarantined, from\n * config-service.\n *\n * Configuration rather than a constant because it is a genuine operational\n * tunable: raising it while a flaky broker settles is a config edit, and the\n * next sweep reads the new value. That is the opposite of a subscription's\n * `maxAttempts`, which becomes an immutable queue argument and therefore stays\n * a literal beside its declaration.\n *\n * ⚠️ **Read it with `getNumber`, never a cast.** A value of `'five'` casts to\n * `NaN`, every `attempts >= maxAttempts` comparison goes false, and nothing is\n * ever quarantined — a relay that looks healthy while its head never moves.\n */\nexport class OutboxMaxAttempts extends Context.Service<\n  OutboxMaxAttempts,\n  number\n>()('OutboxMaxAttempts') {}\n\n/** What {@link drainOutbox} needs beyond the ports it publishes through. */\nexport interface DrainOptions {\n  readonly maxAttempts: number;\n  /** The database being drained; carried so a quarantine log names it. */\n  readonly database: string;\n  /** Where the pass reports what it did; see {@link RelayOutcome}. */\n  readonly onOutcome?: RelayOutcomeSink;\n}\n\n/**\n * Publish one batch of pending entries, oldest first, and answer how many went.\n *\n * Two orderings are load-bearing here and neither is obvious:\n *\n * - A **still-deliverable** failure returns immediately rather than continuing.\n *   The entries behind this one keep their order relative to it, which is what\n *   stops a terminal event overtaking the `accepted` for the same transaction.\n * - A **quarantined** failure continues. That is the deliberate\n *   skip-so-the-head-moves: an entry that can never publish must stop blocking\n *   every entry behind it forever.\n */\nexport const drainOutbox = (\n  outbox: TransactionOutbox,\n  bus: EventBus,\n  options: DrainOptions,\n) =>\n  Effect.gen(function* () {\n    const entries = yield* outbox.pending(BATCH);\n    let sent = 0;\n    const report = options.onOutcome ?? ignoreRelayOutcome;\n    for (const entry of entries) {\n      const outcome = yield* Effect.result(bus.publish(entry.event));\n\n      if (Result.isFailure(outcome)) {\n        const attempts = entry.attempts + 1;\n        const quarantine = attempts >= options.maxAttempts;\n\n        yield* outbox.recordFailure(\n          entry,\n          failureText(outcome.failure),\n          quarantine,\n        );\n\n        if (!quarantine) {\n          yield* report({ _tag: 'drained', database: options.database, sent });\n          return sent;\n        }\n\n        yield* (options.onOutcome ?? ignoreRelayOutcome)({\n          _tag: 'quarantined',\n          database: options.database,\n          eventId: entry.eventId,\n          eventName: entry.event.name,\n          attempts,\n          code: outcome.failure.code,\n          reason: failureText(outcome.failure),\n        });\n        continue;\n      }\n\n      yield* outbox.markSent(entry);\n      sent += 1;\n    }\n    yield* report({ _tag: 'drained', database: options.database, sent });\n    return sent;\n  });\n\n/**\n * Sample a sweep's depth and age.\n *\n * Defaults to {@link recordOutboxStats}, and a caller overrides it only to\n * assert what was sampled. There is no \"no sink\" option on purpose: an outbox\n * whose depth nothing reports is the failure the gauges exist to make visible.\n */\nexport type OutboxStatsSink = (\n  database: string,\n  stats: OutboxStats,\n) => Effect.Effect<void>;\n\n/**\n * Drain the one database this service owns, then sample its depth.\n *\n * The single-database counterpart to `startTenantOutboxRelay`. A\n * platform-plane store is one named database, so there is nothing to enumerate\n * and `listDatabases` — which needs a `MongoClient` and cluster-wide rights —\n * never comes into it.\n *\n * Stats are sampled **after** the drain, so the gauge reports what is still\n * waiting rather than what was waiting when the pass began.\n *\n * Every failure is caught and reported as `sweepFailed`. This runs inside\n * `Effect.forever`, and an error that escapes ends the daemon silently — a\n * relay that stopped is indistinguishable from a relay with nothing to do.\n */\nexport const sweepOutbox = (\n  outbox: TransactionOutbox,\n  bus: EventBus,\n  options: DrainOptions & { readonly onStats?: OutboxStatsSink },\n) =>\n  Effect.gen(function* () {\n    yield* drainOutbox(outbox, bus, options);\n    const sink = options.onStats ?? recordOutboxStats;\n    yield* sink(options.database, yield* outbox.stats());\n  }).pipe(\n    Effect.catch(failure =>\n      (options.onOutcome ?? ignoreRelayOutcome)({\n        _tag: 'sweepFailed',\n        database: options.database,\n        failure,\n      }),\n    ),\n  );\n\n/**\n * Start the relay for a service that owns exactly one database.\n *\n * ⚠️ **The shutdown hook is `flush`, not `stop-intake`, and the phase is the\n * whole point.** `AmqpEventBusLayer` registers `stop-intake` to cancel consumers\n * and drain deliveries; this runs after that, so the last sweep publishes into a\n * connection that is still open. Registered the other way round it would try to\n * publish through a channel already closing, and the entries it was holding\n * would sit until the next boot.\n *\n * The daemon is `delay |> forever`, so the first sweep is one interval away\n * rather than at boot — the write path drains inline, and a sweep racing the\n * index bootstrap on a cold database only produces noise.\n */\nexport const startOutboxRelay = (options?: {\n  readonly onStats?: OutboxStatsSink;\n  readonly onOutcome?: RelayOutcomeSink;\n}) =>\n  Effect.gen(function* () {\n    const db = yield* MongoDatabaseTag;\n    const bus = yield* EventBusTag;\n    const maxAttempts = yield* OutboxMaxAttempts;\n\n    yield* ensureOutboxIndexes(db);\n    const outbox = makeMongoOutbox(db);\n\n    yield* runRelayDaemon(\n      sweepOutbox(outbox, bus, {\n        maxAttempts,\n        database: db.databaseName,\n        ...(options?.onStats ? { onStats: options.onStats } : {}),\n        ...(options?.onOutcome ? { onOutcome: options.onOutcome } : {}),\n      }),\n    );\n  });\n\n/**\n * Runs `sweepOnce` every {@link SWEEP_INTERVAL}, and once more on the way out.\n *\n * Interrupting the daemon before that last pass is what stops two sweeps\n * publishing the same entry; running the pass is what the hook is for — an\n * event committed a moment before shutdown would otherwise wait out the next\n * process's whole interval.\n */\nconst runRelayDaemon = (sweepOnce: Effect.Effect<void>) =>\n  Effect.gen(function* () {\n    const shutdown = yield* ShutdownRegistryTag;\n\n    const daemon = yield* Effect.forkDetach(\n      sweepOnce.pipe(Effect.delay(SWEEP_INTERVAL), Effect.forever),\n    );\n\n    yield* shutdown.register({\n      name: 'outbox-relay',\n      phase: 'flush',\n      run: Fiber.interrupt(daemon).pipe(Effect.andThen(sweepOnce)),\n    });\n  });\n\n/**\n * One pass over every organization's outbox in a per-organization store.\n *\n * ⚠️ **Each tenant is caught on its own.** A failure that recurs — an index\n * conflict on one old database, say — would otherwise abandon every tenant\n * listed after it on every pass, while the relay went on looking healthy.\n *\n * Indexes are ensured once per database per process (`ensured`), not on every\n * pass: a sweep visits every tenant every interval, and the index build is the\n * same request each time.\n */\nexport const sweepTenantOutboxes = (\n  directory: TenantDirectory<Db>,\n  bus: EventBus,\n  options: {\n    readonly maxAttempts: number;\n    readonly onStats?: OutboxStatsSink;\n    readonly onOutcome?: RelayOutcomeSink;\n    readonly ensured?: Set<string>;\n  },\n) =>\n  Effect.gen(function* () {\n    const report = options.onOutcome ?? ignoreRelayOutcome;\n    const ensured = options.ensured ?? new Set<string>();\n    const tenants = yield* directory.list();\n\n    for (const { handle: db } of tenants) {\n      const database = db.databaseName;\n      yield* Effect.gen(function* () {\n        if (!ensured.has(database)) {\n          yield* ensureOutboxIndexes(db);\n          ensured.add(database);\n        }\n        yield* sweepOutbox(makeMongoOutbox(db), bus, {\n          maxAttempts: options.maxAttempts,\n          database,\n          onOutcome: report,\n          ...(options.onStats ? { onStats: options.onStats } : {}),\n        });\n      }).pipe(\n        Effect.catch(failure =>\n          report({ _tag: 'sweepFailed', database, failure }),\n        ),\n      );\n    }\n  }).pipe(\n    Effect.catch(failure =>\n      (options.onOutcome ?? ignoreRelayOutcome)({\n        _tag: 'sweepFailed',\n        failure,\n      }),\n    ),\n  );\n\n/**\n * Start the relay for a store with one database per organization, listed by\n * the {@link TenantDirectoryTag} the host provides.\n *\n * The same two speeds as {@link startOutboxRelay}: the write path drains its\n * own tenant inline with {@link drainOutboxNow}, and this sweep carries\n * whatever that missed.\n */\nexport const startTenantOutboxRelay = (options?: {\n  readonly onStats?: OutboxStatsSink;\n  readonly onOutcome?: RelayOutcomeSink;\n}) =>\n  Effect.gen(function* () {\n    const directory = (yield* TenantDirectoryTag) as TenantDirectory<Db>;\n    const bus = yield* EventBusTag;\n    const maxAttempts = yield* OutboxMaxAttempts;\n    const ensured = new Set<string>();\n\n    yield* runRelayDaemon(\n      sweepTenantOutboxes(directory, bus, {\n        maxAttempts,\n        ensured,\n        ...(options?.onStats ? { onStats: options.onStats } : {}),\n        ...(options?.onOutcome ? { onOutcome: options.onOutcome } : {}),\n      }),\n    );\n  });\n\n/**\n * Drain one database's outbox now, for a write path that has just committed.\n *\n * The fast path the sweep is the fallback for: an event drained here leaves as\n * soon as its transaction commits, rather than up to {@link SWEEP_INTERVAL}\n * later. Every failure is reported as `drainFailed` and swallowed — the entry\n * is still in the outbox, and the sweep will carry it.\n */\nexport const drainOutboxNow = (\n  db: Db,\n  onOutcome: RelayOutcomeSink = ignoreRelayOutcome,\n) =>\n  Effect.gen(function* () {\n    const bus = yield* EventBusTag;\n    const maxAttempts = yield* OutboxMaxAttempts;\n    yield* drainOutbox(makeMongoOutbox(db), bus, {\n      maxAttempts,\n      database: db.databaseName,\n      onOutcome,\n    });\n  }).pipe(\n    Effect.catch(failure =>\n      onOutcome({ _tag: 'drainFailed', database: db.databaseName, failure }),\n    ),\n  );\n"],"names":["ShutdownRegistryTag","TenantDirectoryTag","EventBusTag","Context","Duration","Effect","Fiber","Result","MongoDatabaseTag","recordOutboxStats","ensureOutboxIndexes","makeMongoOutbox","failureText","failure","message","code","SWEEP_INTERVAL","seconds","BATCH","ignoreRelayOutcome","void","OutboxMaxAttempts","Service","drainOutbox","outbox","bus","options","gen","entries","pending","sent","report","onOutcome","entry","outcome","result","publish","event","isFailure","attempts","quarantine","maxAttempts","recordFailure","_tag","database","eventId","eventName","name","reason","markSent","sweepOutbox","sink","onStats","stats","pipe","catch","startOutboxRelay","db","runRelayDaemon","databaseName","sweepOnce","shutdown","daemon","forkDetach","delay","forever","register","phase","run","interrupt","andThen","sweepTenantOutboxes","directory","ensured","Set","tenants","list","handle","has","add","startTenantOutboxRelay","drainOutboxNow"],"mappings":"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"}

package/dist/outbox/store.d.ts

@@ -1,4 +1,4 @@
-import { type DomainEvent, EntifixConnError } from '@entifix/core';
+import type { DomainEvent } from '@entifix/core';
 import type { OutboxEntry, TransactionOutbox } from '@entifix/transactions';
 import { Effect } from 'effect';
 import type { Db } from 'mongodb';
@@ -50,7 +50,7 @@ export declare const outboxDocument: (event: DomainEvent) => OutboxEntry;
  *
  * Answers whether an entry was actually revived.
  */
-export declare const reviveQuarantined: (db: Db, eventId: string) => Effect.Effect<boolean, EntifixConnError, never>;
+export declare const reviveQuarantined: (db: Db, eventId: string) => Effect.Effect<boolean, import("@entifix/core").StoreFailure, never>;
 /**
  * Ensures the two indexes the outbox depends on.
  *
@@ -70,7 +70,7 @@ export declare const reviveQuarantined: (db: Db, eventId: string) => Effect.Effe
  * logs what it catches. The fix is `pnpm run <app>:dev:reset`; nothing runs in
  * production, so there is no migration to write.
  */
-export declare const ensureOutboxIndexes: (db: Db) => Effect.Effect<void, EntifixConnError, never>;
+export declare const ensureOutboxIndexes: (db: Db) => Effect.Effect<void, import("@entifix/core").StoreFailure, never>;
 /**
  * Mongo-backed {@link TransactionOutbox} over one database.
  *

package/dist/outbox/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/outbox/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AAatD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,WAAW,KAAG,WAWlD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,GAAI,IAAI,EAAE,EAAE,SAAS,MAAM,oDAyBrD,CAAC;AAEL;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,GAAI,IAAI,EAAE,iDActC,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,IAAI,EAAE,KAAG,iBA4GxC,CAAC"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/outbox/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAIlC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AAatD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,WAAW,KAAG,WAWlD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,GAAI,IAAI,EAAE,EAAE,SAAS,MAAM,wEAiBrD,CAAC;AAEL;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,GAAI,IAAI,EAAE,qEAWtC,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,IAAI,EAAE,KAAG,iBA4FxC,CAAC"}

package/dist/outbox/store.js

@@ -1,6 +1,6 @@
 import { _ as _extends } from "@swc/helpers/_/_extends";
-import { EntifixConnError } from '@entifix/core';
 import { Effect } from 'effect';
+import { translateMongoError } from '../errors/translate-mongo-error.js';
 /**
  * The outbox collection, and it lives in the **same database as the entity it
  * describes** — never in a shared control-plane store.
@@ -83,10 +83,7 @@ const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && e
             });
             return result.modifiedCount === 1;
         },
-        catch: (error)=>new EntifixConnError('Failed to revive a quarantined outbox entry', error, {
-                eventId,
-                db: db.databaseName
-            })
+        catch: (error)=>translateMongoError(error)
     });
 /**
  * Ensures the two indexes the outbox depends on.
@@ -123,9 +120,7 @@ const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && e
                 }
             });
         },
-        catch: (error)=>new EntifixConnError('Failed to create outbox indexes', error, {
-                db: db.databaseName
-            })
+        catch: (error)=>translateMongoError(error)
     });
 /**
  * Mongo-backed {@link TransactionOutbox} over one database.
@@ -136,7 +131,6 @@ const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && e
  * tested without a broker.
  */ export const makeMongoOutbox = (db)=>{
     const collection = db.collection(OUTBOX_COLLECTION);
-    const fail = (message, error, details)=>new EntifixConnError(message, error, details);
     return {
         enqueue: (event)=>Effect.tryPromise({
                 try: async ()=>{
@@ -152,9 +146,7 @@ const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && e
                         throw error;
                     }
                 },
-                catch: (error)=>fail('Failed to enqueue outbox entry', error, {
-                        eventId: event.id
-                    })
+                catch: (error)=>translateMongoError(error)
             }),
         pending: (limit)=>Effect.tryPromise({
                 // Oldest first, so `accepted` reaches the bus before the terminal event
@@ -165,9 +157,7 @@ const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && e
                     }, WITHOUT_MONGO_ID).sort({
                         createdAt: 1
                     }).limit(limit).toArray(),
-                catch: (error)=>fail('Failed to read pending outbox entries', error, {
-                        db: db.databaseName
-                    })
+                catch: (error)=>translateMongoError(error)
             }),
         markSent: (entry)=>Effect.tryPromise({
                 try: ()=>collection.updateOne({
@@ -177,9 +167,7 @@ const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && e
                             sent: true
                         }
                     }),
-                catch: (error)=>fail('Failed to mark outbox entry sent', error, {
-                        eventId: entry.eventId
-                    })
+                catch: (error)=>translateMongoError(error)
             }).pipe(Effect.asVoid),
         stats: ()=>Effect.tryPromise({
                 // Two counts and one `findOne`, rather than reading the entries: the
@@ -213,7 +201,7 @@ const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && e
                         oldestPendingAt: oldest.createdAt
                     });
                 },
-                catch: (error)=>fail('Failed to read outbox stats', error)
+                catch: (error)=>translateMongoError(error)
             }),
         recordFailure: (entry, error, quarantine)=>Effect.tryPromise({
                 // `$inc` rather than a read-modify-write: two relays can be draining the
@@ -231,9 +219,7 @@ const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && e
                             quarantined: quarantine
                         }
                     }),
-                catch: (cause)=>fail('Failed to record an outbox publish failure', cause, {
-                        eventId: entry.eventId
-                    })
+                catch: (cause)=>translateMongoError(cause)
             }).pipe(Effect.asVoid)
     };
 };

package/dist/outbox/store.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/outbox/store.ts"],"sourcesContent":["import { type DomainEvent, EntifixConnError } from '@entifix/core';\nimport type { OutboxEntry, TransactionOutbox } from '@entifix/transactions';\nimport { Effect } from 'effect';\nimport type { Db } from 'mongodb';\n\n/**\n * The outbox collection, and it lives in the **same database as the entity it\n * describes** — never in a shared control-plane store.\n *\n * Two reasons, and the second only shows up later. Same database means the\n * entity write and its event are one single-database transaction, which stays a\n * single-*shard* transaction if this ever shards; a control-plane outbox would\n * be cross-database from the first commit. And an outbox holds event payloads:\n * a `TransactionEvent` carries no tenant data, but `catalog.published` carries a\n * whole offering and `order.placed` a whole receipt, and neither may land in the\n * control plane on its way to the bus.\n *\n * That rule is why this lives here rather than in one service. It applies\n * identically to a per-organization `tenant_<id>` and to a single platform-plane\n * database, and the second publisher is what turned a copy into a seam.\n */\nexport const OUTBOX_COLLECTION = 'transaction_outbox';\n\n/** Drop Mongo's internal `_id` from every read. */\nconst WITHOUT_MONGO_ID = { projection: { _id: 0 } } as const;\n\n/** Mongo's duplicate-key error, which is how a replayed command is recognised. */\nconst DUPLICATE_KEY = 11000;\n\nconst isDuplicateKey = (error: unknown): boolean =>\n  typeof error === 'object' &&\n  error !== null &&\n  (error as { code?: unknown }).code === DUPLICATE_KEY;\n\n/**\n * The stored shape of an outbox entry.\n *\n * Exported because the `completed` entry is **not** written through the port:\n * it has to join the entity write's session to be atomic with it, and a session\n * cannot live in a framework-free contract. The handler inserts this document\n * itself; everything else goes through {@link makeMongoOutbox}.\n */\nexport const outboxDocument = (event: DomainEvent): OutboxEntry => ({\n  eventId: event.id,\n  event,\n  sent: false,\n  // Defaulted here rather than at each write site because there are two of\n  // them: the relay's `enqueue`, and the transaction handler's own insert\n  // inside the entity's Mongo session. An entry missing `attempts` would sort\n  // into `pending` and then fail `attempts + 1` arithmetic on a `undefined`.\n  attempts: 0,\n  quarantined: false,\n  createdAt: event.at,\n});\n\n/**\n * Puts a **quarantined** entry back in the queue, and touches nothing else.\n *\n * A rebuild walk's repair for the one failure measured on a live lab: with the\n * broker down long enough, the relay spends `outbox.maxAttempts` on an\n * announcement and quarantines it (the deliberate skip-so-the-head-moves),\n * after which the tenant store reads one thing and the storefront shows another\n * with nothing reporting it. Re-emitting cannot help on its own — the event id is\n * `<offeringId>:<publishedAt>` and the unique index answers `duplicate`.\n *\n * ⚠️ **`quarantined: true` is in the filter, not the update.** An entry that is\n * merely pending keeps its `attempts`, and one already `sent` is never re-sent —\n * which is what keeps this from quietly becoming \"re-announce everything\", a\n * walk that would re-publish the whole fleet on every boot and un-quarantine\n * genuine poison each time.\n *\n * Not a `TransactionOutbox` method: the port is framework-free and shared by\n * every publisher, and this is a repair specific to the rebuild. `outboxDocument`\n * is exported beside it for the same class of reason.\n *\n * Answers whether an entry was actually revived.\n */\nexport const reviveQuarantined = (db: Db, eventId: string) =>\n  Effect.tryPromise({\n    try: async () => {\n      const result = await db\n        .collection<OutboxEntry>(OUTBOX_COLLECTION)\n        .updateOne(\n          { eventId, quarantined: true },\n          {\n            $set: { sent: false, quarantined: false, attempts: 0 },\n            // The failure that put it here is spent; leaving it would make the\n            // next quarantine's log name an error from a different outage.\n            $unset: { lastError: '' },\n          },\n        );\n      return result.modifiedCount === 1;\n    },\n    catch: error =>\n      new EntifixConnError(\n        'Failed to revive a quarantined outbox entry',\n        error,\n        {\n          eventId,\n          db: db.databaseName,\n        },\n      ),\n  });\n\n/**\n * Ensures the two indexes the outbox depends on.\n *\n * The unique one is load-bearing rather than defensive: it *is* the idempotency\n * check behind the client-generated transaction id, so a replayed command is\n * rejected by the storage engine rather than by a read-then-write race. It is on\n * `eventId` — `<transactionId>:<step>` for a transaction — so the claim and the\n * bus's deduplication key are one value rather than two that can drift. The\n * partial one keeps the relay's `pending` query cheap once the collection fills\n * with sent entries; it filters on `quarantined` too, so an entry past its\n * ceiling leaves the index rather than being read and skipped forever.\n *\n * Mongo rejects a `createIndex` that reuses a key pattern with a different\n * `partialFilterExpression` (`IndexOptionsConflict`), and this runs on every\n * sweep and every create. A database that predates the `quarantined` filter\n * therefore fails here on every pass — which is loud only because the sweep now\n * logs what it catches. The fix is `pnpm run <app>:dev:reset`; nothing runs in\n * production, so there is no migration to write.\n */\nexport const ensureOutboxIndexes = (db: Db) =>\n  Effect.tryPromise({\n    try: async () => {\n      const collection = db.collection(OUTBOX_COLLECTION);\n      await collection.createIndex({ eventId: 1 }, { unique: true });\n      await collection.createIndex(\n        { createdAt: 1 },\n        { partialFilterExpression: { sent: false, quarantined: false } },\n      );\n    },\n    catch: error =>\n      new EntifixConnError('Failed to create outbox indexes', error, {\n        db: db.databaseName,\n      }),\n  });\n\n/**\n * Mongo-backed {@link TransactionOutbox} over one database.\n *\n * `db` is closed over, so every method's Effect has `R = never` — the same\n * technique `makeMongoRepository` uses. There is no publishing here: the relay\n * composes these methods with the event bus, which is what lets the relay be\n * tested without a broker.\n */\nexport const makeMongoOutbox = (db: Db): TransactionOutbox => {\n  const collection = db.collection<OutboxEntry>(OUTBOX_COLLECTION);\n\n  const fail = (\n    message: string,\n    error: unknown,\n    details?: Record<string, unknown>,\n  ) => new EntifixConnError(message, error, details);\n\n  return {\n    enqueue: event =>\n      Effect.tryPromise({\n        try: async () => {\n          try {\n            await collection.insertOne(outboxDocument(event));\n            return 'enqueued' as const;\n          } catch (error) {\n            // Not a failure: the unique index rejected a second claim for this\n            // message id, which is precisely how a retry is identified.\n            if (isDuplicateKey(error)) {\n              return 'duplicate' as const;\n            }\n            throw error;\n          }\n        },\n        catch: error =>\n          fail('Failed to enqueue outbox entry', error, { eventId: event.id }),\n      }),\n\n    pending: limit =>\n      Effect.tryPromise({\n        // Oldest first, so `accepted` reaches the bus before the terminal event\n        // for the same transaction and the tracker folds them in order.\n        try: () =>\n          collection\n            .find({ sent: false, quarantined: false }, WITHOUT_MONGO_ID)\n            .sort({ createdAt: 1 })\n            .limit(limit)\n            .toArray(),\n        catch: error =>\n          fail('Failed to read pending outbox entries', error, {\n            db: db.databaseName,\n          }),\n      }),\n\n    markSent: entry =>\n      Effect.tryPromise({\n        try: () =>\n          collection.updateOne(\n            { eventId: entry.eventId },\n            { $set: { sent: true } },\n          ),\n        catch: error =>\n          fail('Failed to mark outbox entry sent', error, {\n            eventId: entry.eventId,\n          }),\n      }).pipe(Effect.asVoid),\n\n    stats: () =>\n      Effect.tryPromise({\n        // Two counts and one `findOne`, rather than reading the entries: the\n        // pending set can be arbitrarily large when the relay is stuck, which\n        // is exactly the moment this must stay cheap. Both queries ride the\n        // partial index on `{ createdAt: 1 }` filtered to the same predicate.\n        try: async () => {\n          const pendingFilter = { sent: false, quarantined: false };\n          const [pending, quarantined, oldest] = await Promise.all([\n            collection.countDocuments(pendingFilter),\n            collection.countDocuments({ quarantined: true }),\n            collection.findOne(pendingFilter, {\n              sort: { createdAt: 1 },\n              projection: { _id: 0, createdAt: 1 },\n            }),\n          ]);\n\n          return {\n            pending,\n            quarantined,\n            // Absent rather than zero when the outbox is empty: an age of zero\n            // and \"nothing is waiting\" are opposite conditions, and a gauge\n            // that reports 0 for both is indistinguishable from a healthy relay\n            // at exactly the moment it is not one.\n            ...(oldest === null ? {} : { oldestPendingAt: oldest.createdAt }),\n          };\n        },\n        catch: error => fail('Failed to read outbox stats', error),\n      }),\n\n    recordFailure: (entry, error, quarantine) =>\n      Effect.tryPromise({\n        // `$inc` rather than a read-modify-write: two relays can be draining the\n        // same tenant (the request's inline drain and the daemon sweep), and an\n        // absolute write would let one of them lose the other's attempt and\n        // stretch the ceiling indefinitely.\n        try: () =>\n          collection.updateOne(\n            { eventId: entry.eventId },\n            {\n              $inc: { attempts: 1 },\n              $set: { lastError: error, quarantined: quarantine },\n            },\n          ),\n        catch: cause =>\n          fail('Failed to record an outbox publish failure', cause, {\n            eventId: entry.eventId,\n          }),\n      }).pipe(Effect.asVoid),\n  };\n};\n"],"names":["EntifixConnError","Effect","OUTBOX_COLLECTION","WITHOUT_MONGO_ID","projection","_id","DUPLICATE_KEY","isDuplicateKey","error","code","outboxDocument","event","eventId","id","sent","attempts","quarantined","createdAt","at","reviveQuarantined","db","tryPromise","try","result","collection","updateOne","$set","$unset","lastError","modifiedCount","catch","databaseName","ensureOutboxIndexes","createIndex","unique","partialFilterExpression","makeMongoOutbox","fail","message","details","enqueue","insertOne","pending","limit","find","sort","toArray","markSent","entry","pipe","asVoid","stats","pendingFilter","oldest","Promise","all","countDocuments","findOne","oldestPendingAt","recordFailure","quarantine","$inc","cause"],"mappings":"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"}
+{"version":3,"sources":["../../src/outbox/store.ts"],"sourcesContent":["import type { DomainEvent } from '@entifix/core';\nimport type { OutboxEntry, TransactionOutbox } from '@entifix/transactions';\nimport { Effect } from 'effect';\nimport type { Db } from 'mongodb';\n\nimport { translateMongoError } from '../errors/translate-mongo-error.js';\n\n/**\n * The outbox collection, and it lives in the **same database as the entity it\n * describes** — never in a shared control-plane store.\n *\n * Two reasons, and the second only shows up later. Same database means the\n * entity write and its event are one single-database transaction, which stays a\n * single-*shard* transaction if this ever shards; a control-plane outbox would\n * be cross-database from the first commit. And an outbox holds event payloads:\n * a `TransactionEvent` carries no tenant data, but `catalog.published` carries a\n * whole offering and `order.placed` a whole receipt, and neither may land in the\n * control plane on its way to the bus.\n *\n * That rule is why this lives here rather than in one service. It applies\n * identically to a per-organization `tenant_<id>` and to a single platform-plane\n * database, and the second publisher is what turned a copy into a seam.\n */\nexport const OUTBOX_COLLECTION = 'transaction_outbox';\n\n/** Drop Mongo's internal `_id` from every read. */\nconst WITHOUT_MONGO_ID = { projection: { _id: 0 } } as const;\n\n/** Mongo's duplicate-key error, which is how a replayed command is recognised. */\nconst DUPLICATE_KEY = 11000;\n\nconst isDuplicateKey = (error: unknown): boolean =>\n  typeof error === 'object' &&\n  error !== null &&\n  (error as { code?: unknown }).code === DUPLICATE_KEY;\n\n/**\n * The stored shape of an outbox entry.\n *\n * Exported because the `completed` entry is **not** written through the port:\n * it has to join the entity write's session to be atomic with it, and a session\n * cannot live in a framework-free contract. The handler inserts this document\n * itself; everything else goes through {@link makeMongoOutbox}.\n */\nexport const outboxDocument = (event: DomainEvent): OutboxEntry => ({\n  eventId: event.id,\n  event,\n  sent: false,\n  // Defaulted here rather than at each write site because there are two of\n  // them: the relay's `enqueue`, and the transaction handler's own insert\n  // inside the entity's Mongo session. An entry missing `attempts` would sort\n  // into `pending` and then fail `attempts + 1` arithmetic on a `undefined`.\n  attempts: 0,\n  quarantined: false,\n  createdAt: event.at,\n});\n\n/**\n * Puts a **quarantined** entry back in the queue, and touches nothing else.\n *\n * A rebuild walk's repair for the one failure measured on a live lab: with the\n * broker down long enough, the relay spends `outbox.maxAttempts` on an\n * announcement and quarantines it (the deliberate skip-so-the-head-moves),\n * after which the tenant store reads one thing and the storefront shows another\n * with nothing reporting it. Re-emitting cannot help on its own — the event id is\n * `<offeringId>:<publishedAt>` and the unique index answers `duplicate`.\n *\n * ⚠️ **`quarantined: true` is in the filter, not the update.** An entry that is\n * merely pending keeps its `attempts`, and one already `sent` is never re-sent —\n * which is what keeps this from quietly becoming \"re-announce everything\", a\n * walk that would re-publish the whole fleet on every boot and un-quarantine\n * genuine poison each time.\n *\n * Not a `TransactionOutbox` method: the port is framework-free and shared by\n * every publisher, and this is a repair specific to the rebuild. `outboxDocument`\n * is exported beside it for the same class of reason.\n *\n * Answers whether an entry was actually revived.\n */\nexport const reviveQuarantined = (db: Db, eventId: string) =>\n  Effect.tryPromise({\n    try: async () => {\n      const result = await db\n        .collection<OutboxEntry>(OUTBOX_COLLECTION)\n        .updateOne(\n          { eventId, quarantined: true },\n          {\n            $set: { sent: false, quarantined: false, attempts: 0 },\n            // The failure that put it here is spent; leaving it would make the\n            // next quarantine's log name an error from a different outage.\n            $unset: { lastError: '' },\n          },\n        );\n      return result.modifiedCount === 1;\n    },\n    catch: error => translateMongoError(error),\n  });\n\n/**\n * Ensures the two indexes the outbox depends on.\n *\n * The unique one is load-bearing rather than defensive: it *is* the idempotency\n * check behind the client-generated transaction id, so a replayed command is\n * rejected by the storage engine rather than by a read-then-write race. It is on\n * `eventId` — `<transactionId>:<step>` for a transaction — so the claim and the\n * bus's deduplication key are one value rather than two that can drift. The\n * partial one keeps the relay's `pending` query cheap once the collection fills\n * with sent entries; it filters on `quarantined` too, so an entry past its\n * ceiling leaves the index rather than being read and skipped forever.\n *\n * Mongo rejects a `createIndex` that reuses a key pattern with a different\n * `partialFilterExpression` (`IndexOptionsConflict`), and this runs on every\n * sweep and every create. A database that predates the `quarantined` filter\n * therefore fails here on every pass — which is loud only because the sweep now\n * logs what it catches. The fix is `pnpm run <app>:dev:reset`; nothing runs in\n * production, so there is no migration to write.\n */\nexport const ensureOutboxIndexes = (db: Db) =>\n  Effect.tryPromise({\n    try: async () => {\n      const collection = db.collection(OUTBOX_COLLECTION);\n      await collection.createIndex({ eventId: 1 }, { unique: true });\n      await collection.createIndex(\n        { createdAt: 1 },\n        { partialFilterExpression: { sent: false, quarantined: false } },\n      );\n    },\n    catch: error => translateMongoError(error),\n  });\n\n/**\n * Mongo-backed {@link TransactionOutbox} over one database.\n *\n * `db` is closed over, so every method's Effect has `R = never` — the same\n * technique `makeMongoRepository` uses. There is no publishing here: the relay\n * composes these methods with the event bus, which is what lets the relay be\n * tested without a broker.\n */\nexport const makeMongoOutbox = (db: Db): TransactionOutbox => {\n  const collection = db.collection<OutboxEntry>(OUTBOX_COLLECTION);\n\n  return {\n    enqueue: event =>\n      Effect.tryPromise({\n        try: async () => {\n          try {\n            await collection.insertOne(outboxDocument(event));\n            return 'enqueued' as const;\n          } catch (error) {\n            // Not a failure: the unique index rejected a second claim for this\n            // message id, which is precisely how a retry is identified.\n            if (isDuplicateKey(error)) {\n              return 'duplicate' as const;\n            }\n            throw error;\n          }\n        },\n        catch: error => translateMongoError(error),\n      }),\n\n    pending: limit =>\n      Effect.tryPromise({\n        // Oldest first, so `accepted` reaches the bus before the terminal event\n        // for the same transaction and the tracker folds them in order.\n        try: () =>\n          collection\n            .find({ sent: false, quarantined: false }, WITHOUT_MONGO_ID)\n            .sort({ createdAt: 1 })\n            .limit(limit)\n            .toArray(),\n        catch: error => translateMongoError(error),\n      }),\n\n    markSent: entry =>\n      Effect.tryPromise({\n        try: () =>\n          collection.updateOne(\n            { eventId: entry.eventId },\n            { $set: { sent: true } },\n          ),\n        catch: error => translateMongoError(error),\n      }).pipe(Effect.asVoid),\n\n    stats: () =>\n      Effect.tryPromise({\n        // Two counts and one `findOne`, rather than reading the entries: the\n        // pending set can be arbitrarily large when the relay is stuck, which\n        // is exactly the moment this must stay cheap. Both queries ride the\n        // partial index on `{ createdAt: 1 }` filtered to the same predicate.\n        try: async () => {\n          const pendingFilter = { sent: false, quarantined: false };\n          const [pending, quarantined, oldest] = await Promise.all([\n            collection.countDocuments(pendingFilter),\n            collection.countDocuments({ quarantined: true }),\n            collection.findOne(pendingFilter, {\n              sort: { createdAt: 1 },\n              projection: { _id: 0, createdAt: 1 },\n            }),\n          ]);\n\n          return {\n            pending,\n            quarantined,\n            // Absent rather than zero when the outbox is empty: an age of zero\n            // and \"nothing is waiting\" are opposite conditions, and a gauge\n            // that reports 0 for both is indistinguishable from a healthy relay\n            // at exactly the moment it is not one.\n            ...(oldest === null ? {} : { oldestPendingAt: oldest.createdAt }),\n          };\n        },\n        catch: error => translateMongoError(error),\n      }),\n\n    recordFailure: (entry, error, quarantine) =>\n      Effect.tryPromise({\n        // `$inc` rather than a read-modify-write: two relays can be draining the\n        // same tenant (the request's inline drain and the daemon sweep), and an\n        // absolute write would let one of them lose the other's attempt and\n        // stretch the ceiling indefinitely.\n        try: () =>\n          collection.updateOne(\n            { eventId: entry.eventId },\n            {\n              $inc: { attempts: 1 },\n              $set: { lastError: error, quarantined: quarantine },\n            },\n          ),\n        catch: cause => translateMongoError(cause),\n      }).pipe(Effect.asVoid),\n  };\n};\n"],"names":["Effect","translateMongoError","OUTBOX_COLLECTION","WITHOUT_MONGO_ID","projection","_id","DUPLICATE_KEY","isDuplicateKey","error","code","outboxDocument","event","eventId","id","sent","attempts","quarantined","createdAt","at","reviveQuarantined","db","tryPromise","try","result","collection","updateOne","$set","$unset","lastError","modifiedCount","catch","ensureOutboxIndexes","createIndex","unique","partialFilterExpression","makeMongoOutbox","enqueue","insertOne","pending","limit","find","sort","toArray","markSent","entry","pipe","asVoid","stats","pendingFilter","oldest","Promise","all","countDocuments","findOne","oldestPendingAt","recordFailure","quarantine","$inc","cause"],"mappings":"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"}

package/dist/saga/store.d.ts

@@ -1,4 +1,3 @@
-import { EntifixConnError } from '@entifix/core';
 import { type SagaStore, SagaStoreTag } from '@entifix/transactions';
 import { Effect, Layer } from 'effect';
 import type { Db } from 'mongodb';
@@ -14,14 +13,14 @@ export declare const SAGA_COLLECTION = "saga_instances";
  * second instance for one flow, and `{ state, updatedAt }` for the sweep —
  * without it every pass is a scan of every saga ever run, on a schedule.
  */
-export declare const ensureSagaIndexes: (db: Db) => Effect.Effect<void, EntifixConnError, never>;
+export declare const ensureSagaIndexes: (db: Db) => Effect.Effect<void, import("@entifix/core").StoreFailure, never>;
 /** {@link SagaStore} over one Mongo database. */
 export declare const makeMongoSagaStore: (db: Db) => SagaStore;
 /**
  * Provides {@link SagaStoreTag} from the service's own database, creating the
  * indexes first.
  */
-export declare const MongoSagaStoreLayer: Layer.Layer<SagaStoreTag, EntifixConnError, MongoDatabaseTag>;
+export declare const MongoSagaStoreLayer: Layer.Layer<SagaStoreTag, import("@entifix/core").StoreFailure, MongoDatabaseTag>;
 /**
  * Provides {@link SagaStoreTag} from a database the host **names**, resolved on
  * the shared client — for a process whose saga store is one of several stores
@@ -32,5 +31,5 @@ export declare const MongoSagaStoreLayer: Layer.Layer<SagaStoreTag, EntifixConnE
  */
 export declare const mongoSagaStoreLayer: (options: {
     readonly database: string;
-}) => Layer.Layer<SagaStoreTag, EntifixConnError, MongoClientTag>;
+}) => Layer.Layer<SagaStoreTag, import("@entifix/core").StoreFailure, MongoClientTag>;
 //# sourceMappingURL=store.d.ts.map

package/dist/saga/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/saga/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAIL,KAAK,SAAS,EACd,YAAY,EACb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC,OAAO,EACL,cAAc,EACd,gBAAgB,EACjB,MAAM,qCAAqC,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,eAAe,mBAAmB,CAAC;AAahD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,IAAI,EAAE,iDAUpC,CAAC;AAEL,iDAAiD;AACjD,eAAO,MAAM,kBAAkB,GAAI,IAAI,EAAE,KAAG,SAoI3C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,+DAO/B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,gEASvE,CAAC"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/saga/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,SAAS,EACd,YAAY,EACb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAGlC,OAAO,EACL,cAAc,EACd,gBAAgB,EACjB,MAAM,qCAAqC,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,eAAe,mBAAmB,CAAC;AAUhD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,IAAI,EAAE,qEAOpC,CAAC;AAEL,iDAAiD;AACjD,eAAO,MAAM,kBAAkB,GAAI,IAAI,EAAE,KAAG,SAoI3C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,mFAO/B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,oFASvE,CAAC"}

package/dist/saga/store.js

@@ -1,7 +1,7 @@
 import { _ as _extends } from "@swc/helpers/_/_extends";
-import { EntifixConnError } from '@entifix/core';
 import { SagaStoreTag } from '@entifix/transactions';
 import { Effect, Layer } from 'effect';
+import { translateMongoError } from '../errors/translate-mongo-error.js';
 import { MongoClientTag, MongoDatabaseTag } from '../mongo-database/mongo-database.js';
 /**
  * Saga instances: one document per flow, the durable record a coordinator
@@ -12,9 +12,6 @@ import { MongoClientTag, MongoDatabaseTag } from '../mongo-database/mongo-databa
     'RUNNING',
     'COMPENSATING'
 ];
-const failed = (message, sagaId)=>(error)=>new EntifixConnError(message, error, {
-            sagaId
-        });
 const sagaCollection = (db)=>db.collection(SAGA_COLLECTION);
 const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString();
 /**
@@ -33,9 +30,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                 updatedAt: 1
             });
         },
-        catch: (error)=>new EntifixConnError('Failed to ensure saga indexes', error, {
-                database: db.databaseName
-            })
+        catch: (error)=>translateMongoError(error)
     });
 /** {@link SagaStore} over one Mongo database. */ export const makeMongoSagaStore = (db)=>{
     const collection = sagaCollection(db);
@@ -56,7 +51,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                         upsert: true
                     });
                 },
-                catch: failed('Failed to start the saga instance', instance.sagaId)
+                catch: (error)=>translateMongoError(error)
             }),
         beginStep: (sagaId, stepIndex)=>Effect.tryPromise({
                 try: async ()=>{
@@ -69,7 +64,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                         }
                     });
                 },
-                catch: failed('Failed to record the step transition', sagaId)
+                catch: (error)=>translateMongoError(error)
             }),
         recordOutcome: (sagaId, outcome)=>Effect.tryPromise({
                 try: async ()=>{
@@ -87,7 +82,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                         }
                     });
                 },
-                catch: failed('Failed to record the step outcome', sagaId)
+                catch: (error)=>translateMongoError(error)
             }),
         settle: (sagaId, state, error)=>Effect.tryPromise({
                 try: async ()=>{
@@ -101,7 +96,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                         }
                     });
                 },
-                catch: failed('Failed to settle the saga instance', sagaId)
+                catch: (error)=>translateMongoError(error)
             }),
         /**
      * Take ownership of a stale instance, or answer `undefined`.
@@ -138,7 +133,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                     });
                     return claimed != null ? claimed : undefined;
                 },
-                catch: failed('Failed to claim the saga instance', sagaId)
+                catch: (error)=>translateMongoError(error)
             }),
         /**
      * Flag one step's calls as given back, addressing the outcome by its step
@@ -161,7 +156,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                         ]
                     });
                 },
-                catch: failed('Failed to mark the step compensated', sagaId)
+                catch: (error)=>translateMongoError(error)
             }),
         get: (sagaId)=>Effect.tryPromise({
                 try: async ()=>{
@@ -174,7 +169,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                         }
                     })) != null ? _ref : undefined;
                 },
-                catch: failed('Failed to read the saga instance', sagaId)
+                catch: (error)=>translateMongoError(error)
             }),
         /**
      * Instances stuck mid-flight past a deadline. ⚠️ `COMPENSATING` counts: a
@@ -195,7 +190,7 @@ const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString()
                             _id: 0
                         }
                     }).toArray(),
-                catch: failed('Failed to find stale saga instances', '')
+                catch: (error)=>translateMongoError(error)
             })
     };
 };