@fullstackhouse/open-mercato-durable-work 0.1.0

package/dist/core/terminal.js

@@ -0,0 +1,53 @@
+import { bumpMirrorAttempts, cancelCas, completeCas, failTerminalCas, markMirrored } from "./store.js";
+class DomainMirrorMismatchError extends Error {
+  constructor(jobId) {
+    super(`Domain mirror matched no rows for job ${jobId}`);
+    this.jobId = jobId;
+    this.name = "DomainMirrorMismatchError";
+  }
+}
+async function runTerminalTransition(sql, kind, lease, scope, transition) {
+  let casMatched = false;
+  try {
+    const result = await sql.transaction(async (tx) => {
+      const job = await applyCas(tx, lease, transition);
+      if (!job) return null;
+      casMatched = true;
+      if (transition.type === "cancel" && kind.onCancel) await kind.onCancel(job, scope, tx);
+      if (kind.onTransition) {
+        const { matched } = await kind.onTransition(job, scope, tx);
+        if (matched < 1) throw new DomainMirrorMismatchError(job.id);
+      }
+      await markMirrored(tx, job.id);
+      return { job, mirrored: true };
+    });
+    return result;
+  } catch (error) {
+    if (casMatched) await bumpMirrorAttempts(sql, lease.jobId).catch(() => void 0);
+    throw error;
+  }
+}
+async function applyCas(tx, lease, transition) {
+  switch (transition.type) {
+    case "complete":
+      return completeCas(tx, lease, transition.patch);
+    case "fail":
+      return failTerminalCas(tx, lease, { code: transition.code, class: transition.class, message: transition.message });
+    case "cancel":
+      return cancelCas(tx, lease);
+  }
+}
+async function runAfterTransition(kind, job, scope, onError) {
+  if (!kind.onAfterTransition) return;
+  try {
+    await kind.onAfterTransition(job, scope);
+  } catch (error) {
+    onError?.(error);
+  }
+}
+export {
+  DomainMirrorMismatchError,
+  runAfterTransition,
+  runTerminalTransition
+};
+//# sourceMappingURL=terminal.js.map

package/dist/core/terminal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/terminal.ts"],
+  "sourcesContent": ["// The one code path by which a job reaches `completed`, `failed` or `cancelled`.\n//\n// Everything terminal goes through here so there is a single place where \"the job row and the\n// domain row move together, or neither moves\" is true. The job row is what every surface reads\n// \u2014 the UI, the cancel route, the reconciler \u2014 so a domain row that went terminal while the\n// job row still said `running` would be repaired by the reconciler as an orphan and re-driven,\n// which is worse than the inconsistency it came from.\n\nimport { bumpMirrorAttempts, cancelCas, completeCas, failTerminalCas, markMirrored } from './store'\nimport type { ResolvedKind } from './registry'\nimport type { DurableJob, ErrorClass, Lease, Scope, SqlExecutor, SqlTransactor } from './types'\n\n/** The domain mirror ran but matched no row: the domain record is gone, or another path\n *  already moved it. Treated exactly like a throw \u2014 \"mirrored\" means the domain row agrees,\n *  not that the callback was called. */\nexport class DomainMirrorMismatchError extends Error {\n  constructor(readonly jobId: string) {\n    super(`Domain mirror matched no rows for job ${jobId}`)\n    this.name = 'DomainMirrorMismatchError'\n  }\n}\n\nexport type Transition =\n  | { type: 'complete'; patch?: { processedCount?: number; totalCount?: number | null } }\n  | { type: 'fail'; code: string; class: ErrorClass; message: string | null }\n  | { type: 'cancel' }\n\nexport type TerminalResult = { job: DurableJob; mirrored: boolean }\n\n/**\n * Runs the terminal CAS and the kind's domain mirror in one transaction.\n *\n * Three distinguishable outcomes, and keeping them distinguishable is the point:\n *   - `null`      the CAS matched no rows. The lease was lost or taken; this delivery has no\n *                 say any more and should end quietly.\n *   - a result    committed.\n *   - a throw     the CAS matched but the mirror failed, so everything rolled back. The caller\n *                 decides whether that costs a retry (it does on the ordinary completion path,\n *                 and deliberately does not on the cancellation path).\n *\n * An earlier draft returned `null` for both the refused fence and the rolled-back mirror. The\n * caller then could not tell \"someone else owns this\" from \"try again\", which are opposite\n * instructions.\n */\nexport async function runTerminalTransition(\n  sql: SqlTransactor,\n  kind: ResolvedKind,\n  lease: Lease,\n  scope: Scope,\n  transition: Transition,\n): Promise<TerminalResult | null> {\n  let casMatched = false\n  try {\n    const result = await sql.transaction(async (tx) => {\n      const job = await applyCas(tx, lease, transition)\n      if (!job) return null\n      casMatched = true\n\n      if (transition.type === 'cancel' && kind.onCancel) await kind.onCancel(job, scope, tx)\n\n      if (kind.onTransition) {\n        const { matched } = await kind.onTransition(job, scope, tx)\n        if (matched < 1) throw new DomainMirrorMismatchError(job.id)\n      }\n\n      // Recorded inside the same transaction as the mirror it describes: a job that says its\n      // domain row agrees, when the write that made it agree rolled back, is the exact lie\n      // this protocol exists to prevent.\n      await markMirrored(tx, job.id)\n      return { job, mirrored: true }\n    })\n    return result\n  } catch (error) {\n    // Outside the rolled-back transaction on purpose \u2014 a counter written inside it would roll\n    // back with it, and the job would retry its mirror forever with nothing to show for it.\n    if (casMatched) await bumpMirrorAttempts(sql, lease.jobId).catch(() => undefined)\n    throw error\n  }\n}\n\nasync function applyCas(tx: SqlExecutor, lease: Lease, transition: Transition): Promise<DurableJob | null> {\n  switch (transition.type) {\n    case 'complete':\n      return completeCas(tx, lease, transition.patch)\n    case 'fail':\n      return failTerminalCas(tx, lease, { code: transition.code, class: transition.class, message: transition.message })\n    case 'cancel':\n      return cancelCas(tx, lease)\n  }\n}\n\n/** Runs the kind's after-commit hook. Best-effort and at-most-once by design: it has already\n *  been decided that the job is terminal, and a hook that throws must not undo that or be\n *  retried into a duplicate side effect. */\nexport async function runAfterTransition(\n  kind: ResolvedKind,\n  job: DurableJob,\n  scope: Scope,\n  onError?: (error: unknown) => void,\n): Promise<void> {\n  if (!kind.onAfterTransition) return\n  try {\n    await kind.onAfterTransition(job, scope)\n  } catch (error) {\n    onError?.(error)\n  }\n}\n"],
+  "mappings": "AAQA,SAAS,oBAAoB,WAAW,aAAa,iBAAiB,oBAAoB;AAOnF,MAAM,kCAAkC,MAAM;AAAA,EACnD,YAAqB,OAAe;AAClC,UAAM,yCAAyC,KAAK,EAAE;AADnC;AAEnB,SAAK,OAAO;AAAA,EACd;AACF;AAwBA,eAAsB,sBACpB,KACA,MACA,OACA,OACA,YACgC;AAChC,MAAI,aAAa;AACjB,MAAI;AACF,UAAM,SAAS,MAAM,IAAI,YAAY,OAAO,OAAO;AACjD,YAAM,MAAM,MAAM,SAAS,IAAI,OAAO,UAAU;AAChD,UAAI,CAAC,IAAK,QAAO;AACjB,mBAAa;AAEb,UAAI,WAAW,SAAS,YAAY,KAAK,SAAU,OAAM,KAAK,SAAS,KAAK,OAAO,EAAE;AAErF,UAAI,KAAK,cAAc;AACrB,cAAM,EAAE,QAAQ,IAAI,MAAM,KAAK,aAAa,KAAK,OAAO,EAAE;AAC1D,YAAI,UAAU,EAAG,OAAM,IAAI,0BAA0B,IAAI,EAAE;AAAA,MAC7D;AAKA,YAAM,aAAa,IAAI,IAAI,EAAE;AAC7B,aAAO,EAAE,KAAK,UAAU,KAAK;AAAA,IAC/B,CAAC;AACD,WAAO;AAAA,EACT,SAAS,OAAO;AAGd,QAAI,WAAY,OAAM,mBAAmB,KAAK,MAAM,KAAK,EAAE,MAAM,MAAM,MAAS;AAChF,UAAM;AAAA,EACR;AACF;AAEA,eAAe,SAAS,IAAiB,OAAc,YAAoD;AACzG,UAAQ,WAAW,MAAM;AAAA,IACvB,KAAK;AACH,aAAO,YAAY,IAAI,OAAO,WAAW,KAAK;AAAA,IAChD,KAAK;AACH,aAAO,gBAAgB,IAAI,OAAO,EAAE,MAAM,WAAW,MAAM,OAAO,WAAW,OAAO,SAAS,WAAW,QAAQ,CAAC;AAAA,IACnH,KAAK;AACH,aAAO,UAAU,IAAI,KAAK;AAAA,EAC9B;AACF;AAKA,eAAsB,mBACpB,MACA,KACA,OACA,SACe;AACf,MAAI,CAAC,KAAK,kBAAmB;AAC7B,MAAI;AACF,UAAM,KAAK,kBAAkB,KAAK,KAAK;AAAA,EACzC,SAAS,OAAO;AACd,cAAU,KAAK;AAAA,EACjB;AACF;",
+  "names": []
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/core/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/core/worker.js

@@ -0,0 +1,111 @@
+import { deliveryId, makeOwnerId, parseDeliveryId, queueNameFor } from "./ids.js";
+import { errorMessageOf, NoFurtherAttempts } from "./errors.js";
+import { reconcileOnce } from "./reconciler.js";
+import { registry as globalRegistry } from "./registry.js";
+import { runSlice } from "./run-slice.js";
+import { getJob, recordEnqueue } from "./store.js";
+const RECONCILE_TICK_ID = "durable-work-reconcile";
+const RECONCILE_QUEUE = queueNameFor("reconcile");
+async function enqueueJob(sql, transport, kind, job, opts = {}) {
+  const delivery = { jobId: job.id, seq: job.continuationSeq, redrives: job.redrives };
+  const delayMs = job.nextRunAt ? Math.max(0, job.nextRunAt.getTime() - Date.now()) : 0;
+  const { transportJobId } = await transport.enqueue(job.queueName ?? kind.queue, delivery, {
+    delayMs,
+    retry: kind.retry,
+    tx: opts.tx
+  });
+  await recordEnqueue(opts.tx ?? sql, job.id, transportJobId, job.queueName ?? kind.queue);
+}
+async function startWorker(options) {
+  const registry = options.registry ?? globalRegistry;
+  const owner = options.owner ?? makeOwnerId();
+  const log = options.log ?? (() => void 0);
+  const { sql, transport } = options;
+  const kinds = registry.list().filter((k) => !options.kinds || options.kinds.includes(k.kind));
+  const byQueue = /* @__PURE__ */ new Map();
+  for (const kind of kinds) byQueue.set(kind.queue, [...byQueue.get(kind.queue) ?? [], kind]);
+  const bound = [];
+  for (const [queue, queueKinds] of byQueue) {
+    const concurrency = options.concurrency ?? Math.max(...queueKinds.map((k) => k.concurrency));
+    const activeTimeoutMs = Math.max(...queueKinds.map((k) => k.lease.sliceBudgetMs)) * 2;
+    bound.push(
+      await transport.bind(
+        queue,
+        async (delivery, ctx) => {
+          const job = await loadJob(sql, delivery);
+          if (!job) {
+            log("durable_work.delivery_orphaned", { jobId: delivery.jobId, queue });
+            return;
+          }
+          const kind = registry.get(job.kind);
+          if (!kind) {
+            log("durable_work.no_handler", { jobId: job.id, kind: job.kind });
+            return;
+          }
+          const scope = { tenantId: job.tenantId, organizationId: job.organizationId };
+          const result = await runSlice({ sql, kind, owner, log }, delivery, scope, ctx);
+          if (result.outcome === "yielded" && !ctx.signal.aborted) {
+            const current = await getJob(sql, job.id, scope);
+            if (current && current.status === "pending") await enqueueJob(sql, transport, kind, current).catch((error) => {
+              log("durable_work.reenqueue_failed", { jobId: job.id, error: errorMessageOf(error) });
+            });
+          }
+        },
+        { concurrency, activeTimeoutMs }
+      )
+    );
+  }
+  const reconcile = () => reconcileOnce({
+    sql,
+    registry,
+    graceMs: options.reconcilerGraceMs,
+    log,
+    enqueue: async (job) => {
+      const kind = registry.get(job.kind);
+      if (kind) await enqueueJob(sql, transport, kind, job);
+    }
+  });
+  let tickWorker = null;
+  if (options.tickMs !== 0) {
+    tickWorker = await transport.bind(
+      RECONCILE_QUEUE,
+      async () => {
+        const report = await reconcile();
+        if (report.scanned) log("durable_work.reconciled", report);
+      },
+      { concurrency: 1, activeTimeoutMs: 12e4 }
+    );
+    await transport.upsertTick({ id: RECONCILE_TICK_ID, queue: RECONCILE_QUEUE, everyMs: options.tickMs ?? 15e3 });
+    bound.push(tickWorker);
+  }
+  return {
+    owner,
+    reconcile,
+    async stop() {
+      await transport.close({ timeoutMs: options.drainTimeoutMs ?? 3e4 });
+      await Promise.allSettled(bound.map((worker) => worker.close({ timeoutMs: options.drainTimeoutMs ?? 3e4 })));
+    }
+  };
+}
+async function loadJob(sql, delivery) {
+  const result = await sql.query(
+    `select tenant_id, organization_id from durable_work_jobs where id = $1`,
+    [delivery.jobId]
+  );
+  if (!result.rows.length) return null;
+  const row = result.rows[0];
+  return getJob(sql, delivery.jobId, {
+    tenantId: String(row.tenant_id),
+    organizationId: row.organization_id == null ? null : String(row.organization_id)
+  });
+}
+export {
+  NoFurtherAttempts,
+  RECONCILE_QUEUE,
+  RECONCILE_TICK_ID,
+  deliveryId,
+  enqueueJob,
+  parseDeliveryId,
+  startWorker
+};
+//# sourceMappingURL=worker.js.map

package/dist/core/worker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/worker.ts"],
+  "sourcesContent": ["// The worker process: binds each kind's queue, runs the reconciler tick, and drains on\n// shutdown instead of being killed mid-batch.\n\nimport { deliveryId, makeOwnerId, parseDeliveryId, queueNameFor } from './ids'\nimport { errorMessageOf, NoFurtherAttempts } from './errors'\nimport { reconcileOnce, type ReconcileReport } from './reconciler'\nimport { registry as globalRegistry, type KindRegistry, type ResolvedKind } from './registry'\nimport { runSlice } from './run-slice'\nimport { getJob, recordEnqueue } from './store'\nimport type { DurableJob, Delivery, Scope, SqlTransactor } from './types'\nimport type { BoundWorker, TransportAdapter } from '../transport/types'\n\nexport const RECONCILE_TICK_ID = 'durable-work-reconcile'\nexport const RECONCILE_QUEUE = queueNameFor('reconcile')\n\nexport type WorkerOptions = {\n  sql: SqlTransactor\n  transport: TransportAdapter\n  registry?: KindRegistry\n  /** Restrict this process to a subset of kinds. Everything registered runs by default. */\n  kinds?: string[]\n  concurrency?: number\n  /** How often the reconciler runs. */\n  tickMs?: number\n  reconcilerGraceMs?: number\n  drainTimeoutMs?: number\n  owner?: string\n  log?: (event: string, fields: Record<string, unknown>) => void\n}\n\nexport type DurableWorker = {\n  owner: string\n  /** Runs one reconciler pass immediately. Exposed for the CLI and for tests that would\n   *  otherwise have to wait out a tick. */\n  reconcile(): Promise<ReconcileReport>\n  stop(): Promise<void>\n}\n\n/** Enqueues a delivery for a job, and records the id so a cancellation can remove it. */\nexport async function enqueueJob(\n  sql: SqlTransactor,\n  transport: TransportAdapter,\n  kind: ResolvedKind,\n  job: DurableJob,\n  opts: { tx?: Parameters<typeof recordEnqueue>[0] } = {},\n): Promise<void> {\n  const delivery: Delivery = { jobId: job.id, seq: job.continuationSeq, redrives: job.redrives }\n  // The delay comes from the row's own `next_run_at`, computed on the database clock. Reading\n  // it back as a duration here \u2014 rather than passing a timestamp to the broker \u2014 keeps the\n  // two clocks from having to agree.\n  const delayMs = job.nextRunAt ? Math.max(0, job.nextRunAt.getTime() - Date.now()) : 0\n  const { transportJobId } = await transport.enqueue(job.queueName ?? kind.queue, delivery, {\n    delayMs,\n    retry: kind.retry,\n    tx: opts.tx,\n  })\n  await recordEnqueue(opts.tx ?? sql, job.id, transportJobId, job.queueName ?? kind.queue)\n}\n\nexport async function startWorker(options: WorkerOptions): Promise<DurableWorker> {\n  const registry = options.registry ?? globalRegistry\n  const owner = options.owner ?? makeOwnerId()\n  const log = options.log ?? (() => undefined)\n  const { sql, transport } = options\n\n  const kinds = registry.list().filter((k) => !options.kinds || options.kinds.includes(k.kind))\n  const byQueue = new Map<string, ResolvedKind[]>()\n  for (const kind of kinds) byQueue.set(kind.queue, [...(byQueue.get(kind.queue) ?? []), kind])\n\n  const bound: BoundWorker[] = []\n\n  for (const [queue, queueKinds] of byQueue) {\n    const concurrency = options.concurrency ?? Math.max(...queueKinds.map((k) => k.concurrency))\n    // The broker must tolerate a delivery being in flight for longer than a whole slice, or it\n    // redelivers work that is still running \u2014 which the lease then refuses, wasting the slice.\n    const activeTimeoutMs = Math.max(...queueKinds.map((k) => k.lease.sliceBudgetMs)) * 2\n\n    bound.push(\n      await transport.bind(\n        queue,\n        async (delivery, ctx) => {\n          const job = await loadJob(sql, delivery)\n          if (!job) {\n            log('durable_work.delivery_orphaned', { jobId: delivery.jobId, queue })\n            return\n          }\n          const kind = registry.get(job.kind)\n          if (!kind) {\n            // Nothing in this process can run it. Leave it alone rather than failing it: a\n            // rolling deploy legitimately has processes that do not yet know a new kind, and\n            // the reconciler parks it if nobody ever claims it.\n            log('durable_work.no_handler', { jobId: job.id, kind: job.kind })\n            return\n          }\n          const scope: Scope = { tenantId: job.tenantId, organizationId: job.organizationId }\n          const result = await runSlice({ sql, kind, owner, log }, delivery, scope, ctx)\n          if (result.outcome === 'yielded' && !ctx.signal.aborted) {\n            // The transport's hand-back may have been refused (a lock lost at exactly the\n            // wrong moment). The row is already `pending` at the next seq, so re-enqueuing\n            // under the new identity cannot collide with anything the broker still holds.\n            const current = await getJob(sql, job.id, scope)\n            if (current && current.status === 'pending') await enqueueJob(sql, transport, kind, current).catch((error) => {\n              log('durable_work.reenqueue_failed', { jobId: job.id, error: errorMessageOf(error) })\n            })\n          }\n        },\n        { concurrency, activeTimeoutMs },\n      ),\n    )\n  }\n\n  const reconcile = () =>\n    reconcileOnce({\n      sql,\n      registry,\n      graceMs: options.reconcilerGraceMs,\n      log,\n      enqueue: async (job) => {\n        const kind = registry.get(job.kind)\n        if (kind) await enqueueJob(sql, transport, kind, job)\n      },\n    })\n\n  // The tick is a repeating delivery owned by the broker rather than a job that re-enqueues\n  // itself: a self-re-enqueue is lost the moment one tick fails, and nothing would notice.\n  let tickWorker: BoundWorker | null = null\n  if (options.tickMs !== 0) {\n    tickWorker = await transport.bind(\n      RECONCILE_QUEUE,\n      async () => {\n        const report = await reconcile()\n        if (report.scanned) log('durable_work.reconciled', report as unknown as Record<string, unknown>)\n      },\n      { concurrency: 1, activeTimeoutMs: 120_000 },\n    )\n    await transport.upsertTick({ id: RECONCILE_TICK_ID, queue: RECONCILE_QUEUE, everyMs: options.tickMs ?? 15_000 })\n    bound.push(tickWorker)\n  }\n\n  return {\n    owner,\n    reconcile,\n    async stop() {\n      // Close the transport first: it stops accepting new deliveries and aborts the signal\n      // every in-flight slice is watching, so they hand back at their next boundary rather\n      // than being cut off between two writes.\n      await transport.close({ timeoutMs: options.drainTimeoutMs ?? 30_000 })\n      await Promise.allSettled(bound.map((worker) => worker.close({ timeoutMs: options.drainTimeoutMs ?? 30_000 })))\n    },\n  }\n}\n\nasync function loadJob(sql: SqlTransactor, delivery: Delivery): Promise<DurableJob | null> {\n  // The delivery carries only ids, so the row is read unscoped here and every statement after\n  // it re-scopes from the row's own tenant. A delivery cannot name a scope it should not see:\n  // it can only name a job id that already exists.\n  const result = await sql.query<Record<string, unknown>>(\n    `select tenant_id, organization_id from durable_work_jobs where id = $1`,\n    [delivery.jobId],\n  )\n  if (!result.rows.length) return null\n  const row = result.rows[0]!\n  return getJob(sql, delivery.jobId, {\n    tenantId: String(row.tenant_id),\n    organizationId: row.organization_id == null ? null : String(row.organization_id),\n  })\n}\n\nexport { deliveryId, parseDeliveryId, NoFurtherAttempts }\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/index.js

@@ -0,0 +1,99 @@
+import { metadata } from "./modules/durable_work/index.js";
+import { features } from "./modules/durable_work/acl.js";
+import {
+  TransientError,
+  TerminalError,
+  UnrecoverableError,
+  LeaseLostError,
+  LockKeyHeldError,
+  NoFurtherAttempts,
+  UnknownKindError,
+  classifyError
+} from "./core/errors.js";
+import {
+  DEFAULT_BUDGET,
+  DEFAULT_LEASE,
+  DEFAULT_RETRY,
+  KindRegistry,
+  nextAttemptDelayMs,
+  registry,
+  resolveKind
+} from "./core/registry.js";
+import {
+  CREATE_INDEXES,
+  CREATE_TABLE,
+  DROP_INDEXES,
+  DROP_TABLE,
+  NO_ORG,
+  SCHEMA_STATEMENTS,
+  TABLE
+} from "./core/schema.js";
+import * as store from "./core/store.js";
+import { runSlice } from "./core/run-slice.js";
+import { DomainMirrorMismatchError, runAfterTransition, runTerminalTransition } from "./core/terminal.js";
+import { DurableWorkService } from "./core/service.js";
+import { reconcileOnce } from "./core/reconciler.js";
+import { RECONCILE_QUEUE, RECONCILE_TICK_ID, enqueueJob, startWorker } from "./core/worker.js";
+import { PORTABLE_QUEUE_NAME, deliveryId, makeOwnerId, parseDeliveryId, queueNameFor, sliceIdempotencyKey } from "./core/ids.js";
+import { createTransport, readConfig } from "./om/config.js";
+import { mikroExecutor, mikroTx } from "./om/sql-executor-mikro.js";
+import { createProgressMirror } from "./om/progress-mirror.js";
+import { DurableWorkJob } from "./modules/durable_work/data/entities.js";
+import { MemoryTransport } from "./transport/memory.js";
+import { BullMQTransport } from "./transport/bullmq.js";
+import { PgBossTransport } from "./transport/pgboss.js";
+import { transportConformance } from "./transport/conformance.js";
+export {
+  BullMQTransport,
+  CREATE_INDEXES,
+  CREATE_TABLE,
+  DEFAULT_BUDGET,
+  DEFAULT_LEASE,
+  DEFAULT_RETRY,
+  DROP_INDEXES,
+  DROP_TABLE,
+  DomainMirrorMismatchError,
+  DurableWorkJob,
+  DurableWorkService,
+  KindRegistry,
+  LeaseLostError,
+  LockKeyHeldError,
+  MemoryTransport,
+  NO_ORG,
+  NoFurtherAttempts,
+  PORTABLE_QUEUE_NAME,
+  PgBossTransport,
+  RECONCILE_QUEUE,
+  RECONCILE_TICK_ID,
+  SCHEMA_STATEMENTS,
+  TABLE,
+  TerminalError,
+  TransientError,
+  UnknownKindError,
+  UnrecoverableError,
+  classifyError,
+  createProgressMirror,
+  createTransport,
+  deliveryId,
+  enqueueJob,
+  features,
+  makeOwnerId,
+  metadata,
+  mikroExecutor,
+  mikroTx,
+  nextAttemptDelayMs,
+  parseDeliveryId,
+  queueNameFor,
+  readConfig,
+  reconcileOnce,
+  registry,
+  resolveKind,
+  runAfterTransition,
+  runSlice,
+  runTerminalTransition,
+  sliceIdempotencyKey,
+  startWorker,
+  store,
+  transportConformance
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["// Public API of @fullstackhouse/open-mercato-durable-work.\n//\n// The OM module itself lives at ./modules/durable_work and is loaded by the host through\n// `{ id: 'durable_work', from: '@fullstackhouse/open-mercato-durable-work' }`. Everything\n// exported here is usable without Open Mercato: `core/` speaks to Postgres through\n// `SqlExecutor` and to a broker through `TransportAdapter`, which is what lets the failure\n// harness run the real mechanism with no app around it.\n\nexport { metadata } from './modules/durable_work/index'\nexport { features } from './modules/durable_work/acl'\n\nexport type {\n  Delivery,\n  DurableJob,\n  DurableJobStatus,\n  ErrorClass,\n  Lease,\n  LeaseSettings,\n  BudgetSettings,\n  RetrySettings,\n  OrphanPolicy,\n  ParkReason,\n  Scope,\n  SliceOutcome,\n  SliceVerdict,\n  SqlExecutor,\n  SqlTransactor,\n  StartJobInput,\n} from './core/types'\n\nexport {\n  TransientError,\n  TerminalError,\n  UnrecoverableError,\n  LeaseLostError,\n  LockKeyHeldError,\n  NoFurtherAttempts,\n  UnknownKindError,\n  classifyError,\n} from './core/errors'\n\nexport {\n  DEFAULT_BUDGET,\n  DEFAULT_LEASE,\n  DEFAULT_RETRY,\n  KindRegistry,\n  nextAttemptDelayMs,\n  registry,\n  resolveKind,\n} from './core/registry'\nexport type { KindDefinition, ResolvedKind, SliceContext } from './core/registry'\n\nexport {\n  CREATE_INDEXES,\n  CREATE_TABLE,\n  DROP_INDEXES,\n  DROP_TABLE,\n  NO_ORG,\n  SCHEMA_STATEMENTS,\n  TABLE,\n} from './core/schema'\n\nexport * as store from './core/store'\nexport { runSlice } from './core/run-slice'\nexport type { RunSliceDeps, RunSliceResult } from './core/run-slice'\nexport { DomainMirrorMismatchError, runAfterTransition, runTerminalTransition } from './core/terminal'\nexport type { TerminalResult, Transition } from './core/terminal'\nexport { DurableWorkService } from './core/service'\nexport type { DurableWorkServiceDeps, RedriveRefusal, StartResult } from './core/service'\nexport { reconcileOnce } from './core/reconciler'\nexport type { ReconcileReport, ReconcilerDeps } from './core/reconciler'\nexport { RECONCILE_QUEUE, RECONCILE_TICK_ID, enqueueJob, startWorker } from './core/worker'\nexport type { DurableWorker, WorkerOptions } from './core/worker'\nexport { PORTABLE_QUEUE_NAME, deliveryId, makeOwnerId, parseDeliveryId, queueNameFor, sliceIdempotencyKey } from './core/ids'\n\nexport type {\n  BindOptions,\n  BoundWorker,\n  DeliveryHandler,\n  DeliveryState,\n  EnqueueOptions,\n  HandlerContext,\n  TransportAdapter,\n  TransportName,\n} from './transport/types'\nexport { createTransport, readConfig } from './om/config'\nexport type { DurableWorkConfig } from './om/config'\nexport { mikroExecutor, mikroTx } from './om/sql-executor-mikro'\nexport { createProgressMirror } from './om/progress-mirror'\nexport type { ProgressMirror, ProgressServiceLike } from './om/progress-mirror'\nexport { DurableWorkJob } from './modules/durable_work/data/entities'\n\nexport { MemoryTransport } from './transport/memory'\nexport type { MemoryFaults } from './transport/memory'\nexport { BullMQTransport } from './transport/bullmq'\nexport type { BullMQTransportOptions } from './transport/bullmq'\nexport { PgBossTransport } from './transport/pgboss'\nexport type { PgBossTransportOptions } from './transport/pgboss'\nexport { transportConformance } from './transport/conformance'\nexport type { ConformanceHooks } from './transport/conformance'\n"],
+  "mappings": "AAQA,SAAS,gBAAgB;AACzB,SAAS,gBAAgB;AAqBzB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,YAAY,WAAW;AACvB,SAAS,gBAAgB;AAEzB,SAAS,2BAA2B,oBAAoB,6BAA6B;AAErF,SAAS,0BAA0B;AAEnC,SAAS,qBAAqB;AAE9B,SAAS,iBAAiB,mBAAmB,YAAY,mBAAmB;AAE5E,SAAS,qBAAqB,YAAY,aAAa,iBAAiB,cAAc,2BAA2B;AAYjH,SAAS,iBAAiB,kBAAkB;AAE5C,SAAS,eAAe,eAAe;AACvC,SAAS,4BAA4B;AAErC,SAAS,sBAAsB;AAE/B,SAAS,uBAAuB;AAEhC,SAAS,uBAAuB;AAEhC,SAAS,uBAAuB;AAEhC,SAAS,4BAA4B;",
+  "names": []
+}

package/dist/modules/durable_work/acl.js

@@ -0,0 +1,10 @@
+const features = [
+  { id: "durable_work.view", title: "View durable jobs", module: "durable_work" },
+  { id: "durable_work.operate", title: "Re-drive and cancel durable jobs", module: "durable_work" }
+];
+var acl_default = features;
+export {
+  acl_default as default,
+  features
+};
+//# sourceMappingURL=acl.js.map

package/dist/modules/durable_work/acl.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/durable_work/acl.ts"],
+  "sourcesContent": ["export const features = [\n  { id: 'durable_work.view', title: 'View durable jobs', module: 'durable_work' },\n  { id: 'durable_work.operate', title: 'Re-drive and cancel durable jobs', module: 'durable_work' },\n]\n\nexport default features\n"],
+  "mappings": "AAAO,MAAM,WAAW;AAAA,EACtB,EAAE,IAAI,qBAAqB,OAAO,qBAAqB,QAAQ,eAAe;AAAA,EAC9E,EAAE,IAAI,wBAAwB,OAAO,oCAAoC,QAAQ,eAAe;AAClG;AAEA,IAAO,cAAQ;",
+  "names": []
+}

package/dist/modules/durable_work/api/jobs/[id]/redrive.js

@@ -0,0 +1,20 @@
+import { NextResponse } from "next/server";
+import { routeContext, toDto } from "../../../lib/route-helpers.js";
+const metadata = {
+  POST: { requireAuth: true, requireFeatures: ["durable_work.operate"] }
+};
+async function POST(req, { params }) {
+  const ctx = await routeContext(req);
+  if (ctx instanceof NextResponse) return ctx;
+  const body = await req.json().catch(() => ({}));
+  const result = await ctx.service.redrive(params.id, ctx.scope, { force: body.force === true });
+  if ("refused" in result) {
+    return NextResponse.json({ error: result.refused, heldBy: result.heldBy }, { status: 409 });
+  }
+  return NextResponse.json(toDto(result));
+}
+export {
+  POST,
+  metadata
+};
+//# sourceMappingURL=redrive.js.map

package/dist/modules/durable_work/api/jobs/[id]/redrive.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/modules/durable_work/api/jobs/%5Bid%5D/redrive.ts"],
+  "sourcesContent": ["import { NextResponse } from 'next/server'\n\nimport { routeContext, toDto } from '../../../lib/route-helpers'\n\nexport const metadata = {\n  POST: { requireAuth: true, requireFeatures: ['durable_work.operate'] },\n}\n\n/**\n * Runs a stopped job again.\n *\n * Each refusal is a 409 with a code rather than a generic failure, because the three have\n * different answers: wait for or cancel the job holding the lock key; nothing to re-drive;\n * or say explicitly that re-running an unrecoverable failure is right.\n */\nexport async function POST(req: Request, { params }: { params: { id: string } }) {\n  const ctx = await routeContext(req)\n  if (ctx instanceof NextResponse) return ctx\n\n  const body = (await req.json().catch(() => ({}))) as { force?: boolean }\n  const result = await ctx.service.redrive(params.id, ctx.scope, { force: body.force === true })\n\n  if ('refused' in result) {\n    return NextResponse.json({ error: result.refused, heldBy: result.heldBy }, { status: 409 })\n  }\n  return NextResponse.json(toDto(result))\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAE7B,SAAS,cAAc,aAAa;AAE7B,MAAM,WAAW;AAAA,EACtB,MAAM,EAAE,aAAa,MAAM,iBAAiB,CAAC,sBAAsB,EAAE;AACvE;AASA,eAAsB,KAAK,KAAc,EAAE,OAAO,GAA+B;AAC/E,QAAM,MAAM,MAAM,aAAa,GAAG;AAClC,MAAI,eAAe,aAAc,QAAO;AAExC,QAAM,OAAQ,MAAM,IAAI,KAAK,EAAE,MAAM,OAAO,CAAC,EAAE;AAC/C,QAAM,SAAS,MAAM,IAAI,QAAQ,QAAQ,OAAO,IAAI,IAAI,OAAO,EAAE,OAAO,KAAK,UAAU,KAAK,CAAC;AAE7F,MAAI,aAAa,QAAQ;AACvB,WAAO,aAAa,KAAK,EAAE,OAAO,OAAO,SAAS,QAAQ,OAAO,OAAO,GAAG,EAAE,QAAQ,IAAI,CAAC;AAAA,EAC5F;AACA,SAAO,aAAa,KAAK,MAAM,MAAM,CAAC;AACxC;",
+  "names": []
+}

package/dist/modules/durable_work/api/jobs/[id]/route.js

@@ -0,0 +1,26 @@
+import { NextResponse } from "next/server";
+import { routeContext, toDto } from "../../../lib/route-helpers.js";
+const metadata = {
+  GET: { requireAuth: true, requireFeatures: ["durable_work.view"] },
+  DELETE: { requireAuth: true, requireFeatures: ["durable_work.operate"] }
+};
+async function GET(req, { params }) {
+  const ctx = await routeContext(req);
+  if (ctx instanceof NextResponse) return ctx;
+  const job = await ctx.service.get(params.id, ctx.scope);
+  if (!job) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  return NextResponse.json(toDto(job));
+}
+async function DELETE(req, { params }) {
+  const ctx = await routeContext(req);
+  if (ctx instanceof NextResponse) return ctx;
+  const job = await ctx.service.cancel(params.id, ctx.scope, ctx.userId);
+  if (!job) return NextResponse.json({ error: "Not found or already finished" }, { status: 404 });
+  return NextResponse.json({ ...toDto(job), state: job.status === "cancelled" ? "cancelled" : "cancelling" });
+}
+export {
+  DELETE,
+  GET,
+  metadata
+};
+//# sourceMappingURL=route.js.map

package/dist/modules/durable_work/api/jobs/[id]/route.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/modules/durable_work/api/jobs/%5Bid%5D/route.ts"],
+  "sourcesContent": ["import { NextResponse } from 'next/server'\n\nimport { routeContext, toDto } from '../../../lib/route-helpers'\n\nexport const metadata = {\n  GET: { requireAuth: true, requireFeatures: ['durable_work.view'] },\n  DELETE: { requireAuth: true, requireFeatures: ['durable_work.operate'] },\n}\n\nexport async function GET(req: Request, { params }: { params: { id: string } }) {\n  const ctx = await routeContext(req)\n  if (ctx instanceof NextResponse) return ctx\n  const job = await ctx.service.get(params.id, ctx.scope)\n  if (!job) return NextResponse.json({ error: 'Not found' }, { status: 404 })\n  return NextResponse.json(toDto(job))\n}\n\n/** Asks the job to stop. Answers with what actually happened \u2014 a running job is `cancelling`\n *  until its driver observes the request, and saying `cancelled` before that would be a lie\n *  an operator might act on. */\nexport async function DELETE(req: Request, { params }: { params: { id: string } }) {\n  const ctx = await routeContext(req)\n  if (ctx instanceof NextResponse) return ctx\n  const job = await ctx.service.cancel(params.id, ctx.scope, ctx.userId)\n  if (!job) return NextResponse.json({ error: 'Not found or already finished' }, { status: 404 })\n  return NextResponse.json({ ...toDto(job), state: job.status === 'cancelled' ? 'cancelled' : 'cancelling' })\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAE7B,SAAS,cAAc,aAAa;AAE7B,MAAM,WAAW;AAAA,EACtB,KAAK,EAAE,aAAa,MAAM,iBAAiB,CAAC,mBAAmB,EAAE;AAAA,EACjE,QAAQ,EAAE,aAAa,MAAM,iBAAiB,CAAC,sBAAsB,EAAE;AACzE;AAEA,eAAsB,IAAI,KAAc,EAAE,OAAO,GAA+B;AAC9E,QAAM,MAAM,MAAM,aAAa,GAAG;AAClC,MAAI,eAAe,aAAc,QAAO;AACxC,QAAM,MAAM,MAAM,IAAI,QAAQ,IAAI,OAAO,IAAI,IAAI,KAAK;AACtD,MAAI,CAAC,IAAK,QAAO,aAAa,KAAK,EAAE,OAAO,YAAY,GAAG,EAAE,QAAQ,IAAI,CAAC;AAC1E,SAAO,aAAa,KAAK,MAAM,GAAG,CAAC;AACrC;AAKA,eAAsB,OAAO,KAAc,EAAE,OAAO,GAA+B;AACjF,QAAM,MAAM,MAAM,aAAa,GAAG;AAClC,MAAI,eAAe,aAAc,QAAO;AACxC,QAAM,MAAM,MAAM,IAAI,QAAQ,OAAO,OAAO,IAAI,IAAI,OAAO,IAAI,MAAM;AACrE,MAAI,CAAC,IAAK,QAAO,aAAa,KAAK,EAAE,OAAO,gCAAgC,GAAG,EAAE,QAAQ,IAAI,CAAC;AAC9F,SAAO,aAAa,KAAK,EAAE,GAAG,MAAM,GAAG,GAAG,OAAO,IAAI,WAAW,cAAc,cAAc,aAAa,CAAC;AAC5G;",
+  "names": []
+}

package/dist/modules/durable_work/api/jobs/route.js

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+import { routeContext, toDto } from "../../lib/route-helpers.js";
+const metadata = {
+  GET: { requireAuth: true, requireFeatures: ["durable_work.view"] }
+};
+const STATUSES = /* @__PURE__ */ new Set(["pending", "running", "completed", "failed", "cancelled"]);
+async function GET(req) {
+  const ctx = await routeContext(req);
+  if (ctx instanceof NextResponse) return ctx;
+  const url = new URL(req.url);
+  const status = url.searchParams.get("status");
+  const { items, total } = await ctx.service.list(ctx.scope, {
+    kind: url.searchParams.get("kind") ?? void 0,
+    status: status && STATUSES.has(status) ? status : void 0,
+    page: Number(url.searchParams.get("page") ?? "1"),
+    pageSize: Number(url.searchParams.get("pageSize") ?? "20")
+  });
+  return NextResponse.json({ items: items.map(toDto), total });
+}
+export {
+  GET,
+  metadata
+};
+//# sourceMappingURL=route.js.map

package/dist/modules/durable_work/api/jobs/route.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/durable_work/api/jobs/route.ts"],
+  "sourcesContent": ["import { NextResponse } from 'next/server'\n\nimport { routeContext, toDto } from '../../lib/route-helpers'\nimport type { DurableJobStatus } from '../../../../core/types'\n\nexport const metadata = {\n  GET: { requireAuth: true, requireFeatures: ['durable_work.view'] },\n}\n\nconst STATUSES = new Set<DurableJobStatus>(['pending', 'running', 'completed', 'failed', 'cancelled'])\n\nexport async function GET(req: Request) {\n  const ctx = await routeContext(req)\n  if (ctx instanceof NextResponse) return ctx\n\n  const url = new URL(req.url)\n  const status = url.searchParams.get('status')\n  const { items, total } = await ctx.service.list(ctx.scope, {\n    kind: url.searchParams.get('kind') ?? undefined,\n    status: status && STATUSES.has(status as DurableJobStatus) ? (status as DurableJobStatus) : undefined,\n    page: Number(url.searchParams.get('page') ?? '1'),\n    pageSize: Number(url.searchParams.get('pageSize') ?? '20'),\n  })\n\n  return NextResponse.json({ items: items.map(toDto), total })\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAE7B,SAAS,cAAc,aAAa;AAG7B,MAAM,WAAW;AAAA,EACtB,KAAK,EAAE,aAAa,MAAM,iBAAiB,CAAC,mBAAmB,EAAE;AACnE;AAEA,MAAM,WAAW,oBAAI,IAAsB,CAAC,WAAW,WAAW,aAAa,UAAU,WAAW,CAAC;AAErG,eAAsB,IAAI,KAAc;AACtC,QAAM,MAAM,MAAM,aAAa,GAAG;AAClC,MAAI,eAAe,aAAc,QAAO;AAExC,QAAM,MAAM,IAAI,IAAI,IAAI,GAAG;AAC3B,QAAM,SAAS,IAAI,aAAa,IAAI,QAAQ;AAC5C,QAAM,EAAE,OAAO,MAAM,IAAI,MAAM,IAAI,QAAQ,KAAK,IAAI,OAAO;AAAA,IACzD,MAAM,IAAI,aAAa,IAAI,MAAM,KAAK;AAAA,IACtC,QAAQ,UAAU,SAAS,IAAI,MAA0B,IAAK,SAA8B;AAAA,IAC5F,MAAM,OAAO,IAAI,aAAa,IAAI,MAAM,KAAK,GAAG;AAAA,IAChD,UAAU,OAAO,IAAI,aAAa,IAAI,UAAU,KAAK,IAAI;AAAA,EAC3D,CAAC;AAED,SAAO,aAAa,KAAK,EAAE,OAAO,MAAM,IAAI,KAAK,GAAG,MAAM,CAAC;AAC7D;",
+  "names": []
+}

package/dist/modules/durable_work/cli.js

@@ -0,0 +1,72 @@
+import { createRequestContainer } from "@open-mercato/shared/lib/di/container";
+import { registry } from "../../core/registry.js";
+import { startWorker } from "../../core/worker.js";
+import { readConfig } from "../../om/config.js";
+const flag = (argv, name) => {
+  const index = argv.indexOf(`--${name}`);
+  return index >= 0 ? argv[index + 1] : void 0;
+};
+const emit = (event, fields = {}) => console.log(JSON.stringify({ event, ...fields }));
+const workerCommand = {
+  command: "worker",
+  async run(argv) {
+    const config = readConfig();
+    const container = await createRequestContainer();
+    const sql = container.resolve("durableWorkSql");
+    const transport = container.resolve("durableWorkTransport");
+    const worker = await startWorker({
+      sql,
+      transport,
+      registry,
+      kinds: flag(argv, "kinds")?.split(","),
+      concurrency: flag(argv, "concurrency") ? Number(flag(argv, "concurrency")) : void 0,
+      tickMs: config.tickMs,
+      reconcilerGraceMs: config.reconcilerGraceMs,
+      drainTimeoutMs: config.drainTimeoutMs,
+      log: (event, fields) => emit(event, fields)
+    });
+    emit("durable_work.worker_started", {
+      owner: worker.owner,
+      transport: transport.name,
+      kinds: registry.list().map((kind) => kind.kind)
+    });
+    let stopping = false;
+    const stop = async (signal) => {
+      if (stopping) return;
+      stopping = true;
+      emit("durable_work.worker_draining", { signal, timeoutMs: config.drainTimeoutMs });
+      await worker.stop();
+      emit("durable_work.worker_stopped");
+      process.exit(0);
+    };
+    process.on("SIGTERM", () => void stop("SIGTERM"));
+    process.on("SIGINT", () => void stop("SIGINT"));
+    await new Promise(() => void 0);
+  }
+};
+const reconcileCommand = {
+  command: "reconcile",
+  async run() {
+    const container = await createRequestContainer();
+    const service = container.resolve("durableWorkService");
+    console.log(JSON.stringify(await service.reconcile(), null, 2));
+  }
+};
+const helpCommand = {
+  command: "help",
+  async run() {
+    console.log(
+      [
+        "mercato durable_work worker [--kinds a,b] [--concurrency n]",
+        "    Bind every registered kind, own the reconciler tick, drain on SIGTERM.",
+        "mercato durable_work reconcile",
+        "    Run one reconciler pass and print what it repaired."
+      ].join("\n")
+    );
+  }
+};
+var cli_default = [workerCommand, reconcileCommand, helpCommand];
+export {
+  cli_default as default
+};
+//# sourceMappingURL=cli.js.map

package/dist/modules/durable_work/cli.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/durable_work/cli.ts"],
+  "sourcesContent": ["// The worker process, and the operator's command line.\n//\n// `mercato durable_work worker` is how the mechanism runs in production. It is deliberately its\n// own process: a slice can run for minutes, and hosting that inside the web process means a\n// deploy either kills work mid-batch or holds the deploy open for the length of a slice.\n\nimport type { ModuleCli } from '@open-mercato/shared/modules/registry'\nimport { createRequestContainer } from '@open-mercato/shared/lib/di/container'\n\nimport type { DurableWorkService } from '../../core/service'\nimport { registry } from '../../core/registry'\nimport { startWorker } from '../../core/worker'\nimport { readConfig } from '../../om/config'\nimport type { SqlTransactor } from '../../core/types'\nimport type { TransportAdapter } from '../../transport/types'\n\nconst flag = (argv: string[], name: string): string | undefined => {\n  const index = argv.indexOf(`--${name}`)\n  return index >= 0 ? argv[index + 1] : undefined\n}\n\nconst emit = (event: string, fields: Record<string, unknown> = {}) => console.log(JSON.stringify({ event, ...fields }))\n\nconst workerCommand: ModuleCli = {\n  command: 'worker',\n  async run(argv: string[]) {\n    const config = readConfig()\n    const container = await createRequestContainer()\n    const sql = container.resolve('durableWorkSql') as SqlTransactor\n    const transport = container.resolve('durableWorkTransport') as TransportAdapter\n\n    const worker = await startWorker({\n      sql,\n      transport,\n      registry,\n      kinds: flag(argv, 'kinds')?.split(','),\n      concurrency: flag(argv, 'concurrency') ? Number(flag(argv, 'concurrency')) : undefined,\n      tickMs: config.tickMs,\n      reconcilerGraceMs: config.reconcilerGraceMs,\n      drainTimeoutMs: config.drainTimeoutMs,\n      log: (event, fields) => emit(event, fields),\n    })\n\n    emit('durable_work.worker_started', {\n      owner: worker.owner,\n      transport: transport.name,\n      kinds: registry.list().map((kind) => kind.kind),\n    })\n\n    // SIGTERM is what a deploy sends. Draining rather than exiting is the difference between a\n    // slice handing its remaining work back and a slice being killed between two writes.\n    let stopping = false\n    const stop = async (signal: string) => {\n      if (stopping) return\n      stopping = true\n      emit('durable_work.worker_draining', { signal, timeoutMs: config.drainTimeoutMs })\n      await worker.stop()\n      emit('durable_work.worker_stopped')\n      process.exit(0)\n    }\n    process.on('SIGTERM', () => void stop('SIGTERM'))\n    process.on('SIGINT', () => void stop('SIGINT'))\n\n    await new Promise(() => undefined) // run until signalled\n  },\n}\n\nconst reconcileCommand: ModuleCli = {\n  command: 'reconcile',\n  async run() {\n    const container = await createRequestContainer()\n    const service = container.resolve('durableWorkService') as DurableWorkService\n    console.log(JSON.stringify(await service.reconcile(), null, 2))\n  },\n}\n\nconst helpCommand: ModuleCli = {\n  command: 'help',\n  async run() {\n    console.log(\n      [\n        'mercato durable_work worker [--kinds a,b] [--concurrency n]',\n        '    Bind every registered kind, own the reconciler tick, drain on SIGTERM.',\n        'mercato durable_work reconcile',\n        '    Run one reconciler pass and print what it repaired.',\n      ].join('\\n'),\n    )\n  },\n}\n\nexport default [workerCommand, reconcileCommand, helpCommand]\n"],
+  "mappings": "AAOA,SAAS,8BAA8B;AAGvC,SAAS,gBAAgB;AACzB,SAAS,mBAAmB;AAC5B,SAAS,kBAAkB;AAI3B,MAAM,OAAO,CAAC,MAAgB,SAAqC;AACjE,QAAM,QAAQ,KAAK,QAAQ,KAAK,IAAI,EAAE;AACtC,SAAO,SAAS,IAAI,KAAK,QAAQ,CAAC,IAAI;AACxC;AAEA,MAAM,OAAO,CAAC,OAAe,SAAkC,CAAC,MAAM,QAAQ,IAAI,KAAK,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC;AAEtH,MAAM,gBAA2B;AAAA,EAC/B,SAAS;AAAA,EACT,MAAM,IAAI,MAAgB;AACxB,UAAM,SAAS,WAAW;AAC1B,UAAM,YAAY,MAAM,uBAAuB;AAC/C,UAAM,MAAM,UAAU,QAAQ,gBAAgB;AAC9C,UAAM,YAAY,UAAU,QAAQ,sBAAsB;AAE1D,UAAM,SAAS,MAAM,YAAY;AAAA,MAC/B;AAAA,MACA;AAAA,MACA;AAAA,MACA,OAAO,KAAK,MAAM,OAAO,GAAG,MAAM,GAAG;AAAA,MACrC,aAAa,KAAK,MAAM,aAAa,IAAI,OAAO,KAAK,MAAM,aAAa,CAAC,IAAI;AAAA,MAC7E,QAAQ,OAAO;AAAA,MACf,mBAAmB,OAAO;AAAA,MAC1B,gBAAgB,OAAO;AAAA,MACvB,KAAK,CAAC,OAAO,WAAW,KAAK,OAAO,MAAM;AAAA,IAC5C,CAAC;AAED,SAAK,+BAA+B;AAAA,MAClC,OAAO,OAAO;AAAA,MACd,WAAW,UAAU;AAAA,MACrB,OAAO,SAAS,KAAK,EAAE,IAAI,CAAC,SAAS,KAAK,IAAI;AAAA,IAChD,CAAC;AAID,QAAI,WAAW;AACf,UAAM,OAAO,OAAO,WAAmB;AACrC,UAAI,SAAU;AACd,iBAAW;AACX,WAAK,gCAAgC,EAAE,QAAQ,WAAW,OAAO,eAAe,CAAC;AACjF,YAAM,OAAO,KAAK;AAClB,WAAK,6BAA6B;AAClC,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,YAAQ,GAAG,WAAW,MAAM,KAAK,KAAK,SAAS,CAAC;AAChD,YAAQ,GAAG,UAAU,MAAM,KAAK,KAAK,QAAQ,CAAC;AAE9C,UAAM,IAAI,QAAQ,MAAM,MAAS;AAAA,EACnC;AACF;AAEA,MAAM,mBAA8B;AAAA,EAClC,SAAS;AAAA,EACT,MAAM,MAAM;AACV,UAAM,YAAY,MAAM,uBAAuB;AAC/C,UAAM,UAAU,UAAU,QAAQ,oBAAoB;AACtD,YAAQ,IAAI,KAAK,UAAU,MAAM,QAAQ,UAAU,GAAG,MAAM,CAAC,CAAC;AAAA,EAChE;AACF;AAEA,MAAM,cAAyB;AAAA,EAC7B,SAAS;AAAA,EACT,MAAM,MAAM;AACV,YAAQ;AAAA,MACN;AAAA,QACE;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,EAAE,KAAK,IAAI;AAAA,IACb;AAAA,EACF;AACF;AAEA,IAAO,cAAQ,CAAC,eAAe,kBAAkB,WAAW;",
+  "names": []
+}