@dudousxd/nestjs-durable-transport-db 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -72,7 +72,21 @@ __name(mikroOrmExecutor, "mikroOrmExecutor");
 
 // src/db-transport.ts
 var RUNS_INSERT_CHUNK = 500;
+var DEADLOCK_RETRIES = 5;
+function isDeadlock(err) {
+  const codes = [
+    err.code,
+    err.errno,
+    err.driverError?.code,
+    err.driverError?.errno
+  ];
+  return codes.some((c) => c === "ER_LOCK_DEADLOCK" || c === 1213 || c === "40P01");
+}
+__name(isDeadlock, "isDeadlock");
+var TASKS_INSERT_CHUNK = 200;
 var RUNS_CLAIM_MAX = 50;
+var RESULTS_IN_FLIGHT = 512;
+var RESULTS_CLAIM_MAX = 256;
 function numberOption(value, fallback, min) {
   return value !== void 0 && Number.isFinite(value) && value >= min ? value : fallback;
 }
@@ -102,6 +116,10 @@ var DbTransport = class {
   resultLoop;
   /** Tasks running on this instance (at most `concurrency`). */
   runningTasks = /* @__PURE__ */ new Set();
+  /** Claim rounds of results being handled on this instance — see {@link drainResults}. */
+  runningResults = /* @__PURE__ */ new Set();
+  /** Results being handled across {@link runningResults} (at most {@link RESULTS_IN_FLIGHT}). */
+  resultsInFlight = 0;
   /** Claim tokens this instance holds, by table — every one is renewed on `renewTimer`. */
   held = /* @__PURE__ */ new Map();
   renewTimer;
@@ -203,9 +221,15 @@ var DbTransport = class {
   }
   // ── engine → worker ────────────────────────────────────────────────────────────────────────
   async dispatch(task) {
+    await this.dispatchMany([
+      task
+    ]);
+  }
+  /** {@link dispatch} for many tasks: one multi-row insert per {@link TASKS_INSERT_CHUNK} tasks. */
+  async dispatchMany(tasks) {
+    if (tasks.length === 0) return;
     await this.ensureSchema();
     const t = this.q(this.tasksTable);
-    const ignore = this.isPg ? `INSERT INTO ${t} (...) ON CONFLICT (${this.q("step_id")}) DO NOTHING` : `INSERT IGNORE INTO ${t} (...)`;
     const cols = [
       "step_id",
       "run_id",
@@ -217,18 +241,24 @@ var DbTransport = class {
       "status",
       "created_at"
     ];
-    const sql = ignore.replace("(...)", `(${cols.map((c) => this.q(c)).join(", ")}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(", ")})`);
-    await this.exec.query(sql, [
-      task.stepId,
-      task.runId,
-      task.seq,
-      task.name,
-      task.group,
-      JSON.stringify(task.input ?? null),
-      task.attempt,
-      "pending",
-      this.now()
-    ]);
+    for (let at = 0; at < tasks.length; at += TASKS_INSERT_CHUNK) {
+      const chunk = tasks.slice(at, at + TASKS_INSERT_CHUNK);
+      const values = chunk.map((_, r) => `(${cols.map((__, c) => this.ph(r * cols.length + c + 1)).join(", ")})`).join(", ");
+      const into = `${t} (${cols.map((c) => this.q(c)).join(", ")}) VALUES ${values}`;
+      const sql = this.isPg ? `INSERT INTO ${into} ON CONFLICT (${this.q("step_id")}) DO NOTHING` : `INSERT IGNORE INTO ${into}`;
+      const now = this.now();
+      await this.exec.query(sql, chunk.flatMap((task) => [
+        task.stepId,
+        task.runId,
+        task.seq,
+        task.name,
+        task.group,
+        JSON.stringify(task.input ?? null),
+        task.attempt,
+        "pending",
+        now
+      ]));
+    }
   }
   // ── worker → engine ────────────────────────────────────────────────────────────────────────
   handle(name, fn) {
@@ -258,7 +288,7 @@ var DbTransport = class {
     }
     const unique = [
       ...byRun.values()
-    ];
+    ].sort((a, b) => a.runId < b.runId ? -1 : a.runId > b.runId ? 1 : 0);
     const t = this.q(this.runsTable);
     const cols = [
       "run_id",
@@ -279,13 +309,13 @@ var DbTransport = class {
       ].map((c) => `${this.q(c)} = NULL`).join(", ");
       const wake = this.q("wake");
       const sql = this.isPg ? `INSERT ${insert} ON CONFLICT (${this.q("run_id")}) DO UPDATE SET ${release}, ${wake} = GREATEST(${t}.${wake}, EXCLUDED.${wake})` : `INSERT ${insert} ON DUPLICATE KEY UPDATE ${release}, ${wake} = GREATEST(${wake}, VALUES(${wake}))`;
-      await this.exec.query(sql, chunk.flatMap((run, r) => [
+      await this.retryOnDeadlock(() => this.exec.query(sql, chunk.flatMap((run, r) => [
         run.runId,
         opts?.namespace ?? "",
         run.priority ?? 0,
         run.reason === "wake" ? 1 : 0,
         now + r
-      ]));
+      ])));
     }
   }
   /**
@@ -333,15 +363,15 @@ var DbTransport = class {
         let rows = [];
         try {
           await this.ensureSchema();
-          rows = await this.claimRuns(ns, Math.min(free, RUNS_CLAIM_MAX));
+          rows = await this.retryOnDeadlock(() => this.claimRuns(ns, Math.min(free, RUNS_CLAIM_MAX)));
         } catch (err) {
           if (this.running && !consumer.stopped) this.onError(err);
         }
         for (const { run, token } of rows) {
           consumer.inflight.add(token);
-          const done = handler(run).catch(() => void 0).then(() => this.exec.query(`DELETE FROM ${this.q(this.runsTable)} WHERE ${this.q("claim_token")} = ${this.ph(1)}`, [
+          const done = handler(run).catch(() => void 0).then(() => this.retryOnDeadlock(() => this.exec.query(`DELETE FROM ${this.q(this.runsTable)} WHERE ${this.q("claim_token")} = ${this.ph(1)}`, [
             token
-          ]).catch(() => void 0)).finally(() => {
+          ])).catch(() => void 0)).finally(() => {
             consumer.inflight.delete(token);
             settled.delete(done);
             consumer.slotFreed?.();
@@ -357,6 +387,21 @@ var DbTransport = class {
       clearInterval(renew);
     }
   }
+  /**
+  * Run `statement`, again on a deadlock: queueing a run (an upsert), taking one (`SKIP LOCKED`)
+  * and deleting a handled one touch the same rows from different instances, and the database then
+  * rolls one of them back rather than wait (InnoDB reports `ER_LOCK_DEADLOCK`, Postgres `40P01`).
+  */
+  async retryOnDeadlock(statement) {
+    for (let attempt = 1; ; attempt += 1) {
+      try {
+        return await statement();
+      } catch (err) {
+        if (attempt >= DEADLOCK_RETRIES || !isDeadlock(err)) throw err;
+        await this.sleep(10 * attempt + Math.floor(Math.random() * 10));
+      }
+    }
+  }
   async claimRuns(ns, limit) {
     const t = this.q(this.runsTable);
     const staleBefore = this.now() - this.leaseMs;
@@ -508,43 +553,61 @@ var DbTransport = class {
     });
   }
   /**
-  * Claim a batch of results, deliver each to the engine, and delete it — only after its handler ran
-  * (at-least-once), and only while this round still holds the claim (a newer result for the same
-  * step that replaced the row resets the claim, so it is delivered next instead of deleted). The
-  * batch's claim is renewed until it is done. A throwing handler is reported and its row left for
-  * re-delivery after the lease; the rest of the batch continues.
+  * Claim a batch of results and hand them all to the engine at once, then delete the ones whose
+  * handler resolved — only after it did (at-least-once), and only while this round still holds the
+  * claim (a newer result for the same step that replaced the row resets the claim, so it is
+  * delivered next instead of deleted). The next round is claimed while this one runs, up to
+  * {@link RESULTS_IN_FLIGHT} results; the round's claim is renewed until it is done. A throwing
+  * handler is reported and its row left for re-delivery after the lease.
   */
   async drainResults(handler) {
-    const { rows, token } = await this.claim(this.resultsTable, this.batchSize, "1 = 1", []);
+    const free = RESULTS_IN_FLIGHT - this.resultsInFlight;
+    if (free <= 0) {
+      await Promise.race(this.runningResults);
+      return 1;
+    }
+    const { rows, token } = await this.claim(this.resultsTable, Math.min(free, Math.max(this.batchSize, RESULTS_CLAIM_MAX)), "1 = 1", []);
     if (rows.length === 0) return 0;
     this.hold(this.resultsTable, token);
-    try {
-      for (const row of rows) {
-        if (!this.running) break;
-        try {
-          const result = {
-            runId: row.run_id,
-            seq: Number(row.seq),
-            stepId: row.step_id,
-            status: row.status,
-            output: row.output == null ? void 0 : JSON.parse(row.output),
-            error: row.error == null ? void 0 : JSON.parse(row.error),
-            startedAt: row.started_at == null ? void 0 : Number(row.started_at)
-          };
-          await handler(result);
-          await this.exec.query(`DELETE FROM ${this.q(this.resultsTable)} WHERE ${this.q("step_id")} = ${this.ph(1)} AND ${this.q("claimed_by")} = ${this.ph(2)}`, [
-            row.step_id,
-            token
-          ]);
-        } catch (err) {
-          this.onError(err);
-        }
-      }
-    } finally {
+    this.resultsInFlight += rows.length;
+    const round = this.handleResults(rows, token, handler).finally(() => {
+      this.resultsInFlight -= rows.length;
+      this.runningResults.delete(round);
       this.release(this.resultsTable, token);
-    }
+    });
+    this.runningResults.add(round);
     return rows.length;
   }
+  /** Hand one claimed round of results to the engine, then delete the delivered ones in one statement. */
+  async handleResults(rows, token, handler) {
+    const delivered = [];
+    await Promise.all(rows.map(async (row) => {
+      try {
+        await handler({
+          runId: row.run_id,
+          seq: Number(row.seq),
+          stepId: row.step_id,
+          status: row.status,
+          output: row.output == null ? void 0 : JSON.parse(row.output),
+          error: row.error == null ? void 0 : JSON.parse(row.error),
+          startedAt: row.started_at == null ? void 0 : Number(row.started_at)
+        });
+        delivered.push(row.step_id);
+      } catch (err) {
+        this.onError(err);
+      }
+    }));
+    if (delivered.length === 0) return;
+    try {
+      const ids = delivered.map((_, i) => this.ph(i + 2)).join(", ");
+      await this.exec.query(`DELETE FROM ${this.q(this.resultsTable)} WHERE ${this.q("claimed_by")} = ${this.ph(1)} AND ${this.q("step_id")} IN (${ids})`, [
+        token,
+        ...delivered
+      ]);
+    } catch (err) {
+      this.onError(err);
+    }
+  }
   /**
   * Atomically claim up to `limit` un-leased rows matching `where` and stamp them with a claim token
   * unique to this round (`<instanceId>:<uuid>`). `SELECT … FOR UPDATE SKIP LOCKED` inside the txn
@@ -682,7 +745,8 @@ var DbTransport = class {
       ].map((c) => this.stopRunConsumer(c))
     ]);
     await Promise.allSettled([
-      ...this.runningTasks
+      ...this.runningTasks,
+      ...this.runningResults
     ]);
     if (this.renewTimer) clearInterval(this.renewTimer);
     this.renewTimer = void 0;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/db-transport.ts","../src/executors.ts"],"sourcesContent":["export * from './db-transport';\n","import { randomUUID } from 'node:crypto';\nimport {\n  type Heartbeat,\n  type RemoteTask,\n  type RunConsumerOptions,\n  type RunDispatch,\n  type RunQueueOptions,\n  type StepHandler,\n  type StepResult,\n  type Transport,\n  runStepHandler,\n} from '@dudousxd/nestjs-durable-core';\nimport type { SqlExecutor, SqlTx } from './executors';\n\nexport { mikroOrmExecutor, type SqlExecutor, type SqlTx, typeOrmExecutor } from './executors';\n\n/** Raw row shapes returned by `SELECT *` (declared fields, so they're not `| undefined` under noUncheckedIndexedAccess). */\ninterface TaskRow {\n  step_id: string;\n  run_id: string;\n  seq: string | number;\n  name: string;\n  input: string | null;\n  attempt: string | number;\n}\ninterface RunRow {\n  run_id: string;\n  wake: number | string;\n}\n\n/** A claimed run row: its run id and the token of this claim. */\ninterface ClaimedRun {\n  run: RunDispatch;\n  token: string;\n}\n\n/** Most rows one {@link DbTransport.dispatchRuns} insert writes. */\nconst RUNS_INSERT_CHUNK = 500;\n/** Most run rows one consumer poll claims. */\nconst RUNS_CLAIM_MAX = 50;\n\n/** A run-queue consumer started by {@link DbTransport.onDispatchedRun}. */\ninterface RunConsumer {\n  stopped: boolean;\n  /** Claim tokens of the rows whose runs are in flight. */\n  inflight: Set<string>;\n  slotFreed: (() => void) | undefined;\n  loop: Promise<void>;\n}\n\ninterface ResultRow {\n  step_id: string;\n  run_id: string;\n  seq: string | number;\n  status: string;\n  output: string | null;\n  error: string | null;\n  started_at: string | number | null;\n}\n\nexport interface DbTransportOptions {\n  /**\n   * How to run SQL — built from the app's **own** ORM/connection (no broker, no extra connection).\n   * Use `mikroOrmExecutor(em)` to ride the app's MikroORM, `typeOrmExecutor(dataSource)` for TypeORM,\n   * `drizzlePgExecutor(db)` (from `@dudousxd/nestjs-durable-store-drizzle/pg`) for Drizzle on\n   * Postgres, or implement `SqlExecutor` for anything else.\n   */\n  executor: SqlExecutor;\n  /** The worker group this instance serves. Required to register `handle()` consumers. */\n  group?: string;\n  /**\n   * Table-name prefix. Tables: `${prefix}_transport_tasks` / `${prefix}_transport_results`, and\n   * `${prefix}_transport_runs` for the run queue. Default `durable`.\n   */\n  prefix?: string;\n  /** Poll interval in ms when a queue is empty. Default 500. */\n  pollMs?: number;\n  /**\n   * How long a claimed row is owned before it's reclaimable (crash recovery), in ms. Default 30_000.\n   * Every claim this instance holds is renewed every `leaseMs / 3` while it is waiting or running, so\n   * a step may run longer than `leaseMs`; only a crashed (or event-loop-blocked) instance loses it.\n   */\n  leaseMs?: number;\n  /**\n   * Max rows claimed per poll. Default 10. The task loop claims only as many rows as it has free\n   * {@link concurrency} slots (capped by this); the results loop claims up to this many.\n   */\n  batchSize?: number;\n  /**\n   * How many tasks this instance runs at once (worker side). Default 1. A row is claimed only when a\n   * slot is free to run it, so rows never wait claimed behind a slow task while a sibling sits idle.\n   */\n  concurrency?: number;\n  /**\n   * Where a transport failure is reported: a failing poll, a throwing result handler (the result is\n   * re-delivered after the lease), a lost claim. Default `console.error`.\n   */\n  onError?: (err: unknown) => void;\n  /** Create the tables on first use if missing. Default true. */\n  autoCreate?: boolean;\n  /** Identifies this instance in `claimed_by` (for debugging). Defaults to a random id. */\n  instanceId?: string;\n}\n\n/**\n * A numeric option: `fallback` unless `value` is a finite number of at least `min`. `Math.max(1, NaN)`\n * is `NaN`, so a clamp alone would let a `NaN` through (to `LIMIT NaN`, or a `NaN` timer).\n */\nfunction numberOption(value: number | undefined, fallback: number, min: number): number {\n  return value !== undefined && Number.isFinite(value) && value >= min ? value : fallback;\n}\n\n/**\n * A SQL-backed `Transport` — DBOS-style. Instead of a broker (Redis/SQS), remote steps are **rows**\n * in the same database the durable store already uses: `dispatch` inserts a task row, a worker\n * claims it with `SELECT … FOR UPDATE SKIP LOCKED` (so instances never double-claim), runs it, and\n * writes a result row the engine polls. Zero new infrastructure — the DB you already have IS the\n * queue.\n *\n * Trade-off vs a real broker: throughput is bounded by polling + row contention. Great for\n * workflow/pipeline scale (modest rate, long steps); not for high-fanout firehoses.\n *\n * Requires `FOR UPDATE SKIP LOCKED` — **MySQL 8+** or **Postgres 9.5+** (not SQLite). Run one\n * instance engine-side (`onResult`, dispatches) and one per worker process (`handle()` for its group).\n */\nexport class DbTransport implements Transport {\n  private readonly exec: SqlExecutor;\n  private readonly group?: string | undefined;\n  private readonly tasksTable: string;\n  private readonly resultsTable: string;\n  private readonly runsTable: string;\n  private readonly runConsumers = new Set<RunConsumer>();\n  private readonly pollMs: number;\n  private readonly leaseMs: number;\n  private readonly batchSize: number;\n  private readonly concurrency: number;\n  private readonly onError: (err: unknown) => void;\n  private readonly autoCreate: boolean;\n  private readonly instanceId: string;\n  private readonly isPg: boolean;\n\n  private readonly handlers = new Map<string, StepHandler>();\n  private running = true;\n  private schemaReady?: Promise<void> | undefined;\n  private taskLoop?: Promise<void>;\n  private resultLoop?: Promise<void>;\n  /** Tasks running on this instance (at most `concurrency`). */\n  private readonly runningTasks = new Set<Promise<void>>();\n  /** Claim tokens this instance holds, by table — every one is renewed on `renewTimer`. */\n  private readonly held = new Map<string, Set<string>>();\n  private renewTimer?: ReturnType<typeof setInterval> | undefined;\n  private renewal?: Promise<void> | undefined;\n\n  constructor(options: DbTransportOptions) {\n    this.exec = options.executor;\n    this.group = options.group;\n    const prefix = options.prefix ?? 'durable';\n    this.tasksTable = `${prefix}_transport_tasks`;\n    this.resultsTable = `${prefix}_transport_results`;\n    this.runsTable = `${prefix}_transport_runs`;\n    this.pollMs = numberOption(options.pollMs, 500, 0);\n    this.leaseMs = numberOption(options.leaseMs, 30_000, 1);\n    this.batchSize = Math.floor(numberOption(options.batchSize, 10, 1));\n    this.concurrency = Math.floor(numberOption(options.concurrency, 1, 1));\n    this.onError = options.onError ?? ((err) => console.error('[DbTransport]', err));\n    this.autoCreate = options.autoCreate ?? true;\n    // Random, not time-based: two instances booted in the same millisecond must not share an id.\n    this.instanceId = options.instanceId ?? `db-${randomUUID()}`;\n    this.isPg = this.exec.dialect === 'postgres';\n  }\n\n  // ── dialect helpers ──────────────────────────────────────────────────────────────────────────\n  /** Positional placeholder for param `i` (1-based): `$i` on Postgres, `?` elsewhere. */\n  private ph(i: number): string {\n    return this.isPg ? `$${i}` : '?';\n  }\n  private q(id: string): string {\n    return this.exec.escapeId(id);\n  }\n  private now(): number {\n    return Math.floor(Date.now());\n  }\n\n  // ── schema ───────────────────────────────────────────────────────────────────────────────────\n  private ensureSchema(): Promise<void> {\n    if (!this.schemaReady) {\n      // A failed attempt is not cached: the next call tries again instead of failing forever.\n      this.schemaReady = this.createTables().catch((err) => {\n        this.schemaReady = undefined;\n        throw err;\n      });\n    }\n    return this.schemaReady;\n  }\n\n  /**\n   * Run one `CREATE … IF NOT EXISTS`. Two instances booting on a fresh database race it, and Postgres\n   * can reject the loser with a unique violation on its catalog even with `IF NOT EXISTS`; the\n   * statement is simply re-run, by which point the table exists and it is a no-op.\n   */\n  private async createIfMissing(sql: string): Promise<void> {\n    try {\n      await this.exec.query(sql);\n    } catch {\n      await this.exec.query(sql);\n    }\n  }\n\n  private async createTables(): Promise<void> {\n    if (!this.autoCreate) return;\n    const str = 'varchar(191)';\n    const txt = this.isPg ? 'text' : 'longtext';\n    const tasks = this.q(this.tasksTable);\n    const results = this.q(this.resultsTable);\n    await this.createIfMissing(\n      `CREATE TABLE IF NOT EXISTS ${tasks} (\n        ${this.q('step_id')} ${str} PRIMARY KEY,\n        ${this.q('run_id')} ${str} NOT NULL,\n        ${this.q('seq')} integer NOT NULL,\n        ${this.q('name')} ${str} NOT NULL,\n        ${this.q('grp')} ${str} NOT NULL,\n        ${this.q('input')} ${txt},\n        ${this.q('attempt')} integer NOT NULL,\n        ${this.q('status')} varchar(32) NOT NULL,\n        ${this.q('claimed_by')} ${str},\n        ${this.q('claimed_at')} bigint,\n        ${this.q('created_at')} bigint NOT NULL\n      )`,\n    );\n    await this.createIfMissing(\n      `CREATE TABLE IF NOT EXISTS ${results} (\n        ${this.q('step_id')} ${str} PRIMARY KEY,\n        ${this.q('run_id')} ${str} NOT NULL,\n        ${this.q('seq')} integer NOT NULL,\n        ${this.q('status')} varchar(32) NOT NULL,\n        ${this.q('output')} ${txt},\n        ${this.q('error')} ${txt},\n        ${this.q('started_at')} bigint,\n        ${this.q('claimed_by')} ${str},\n        ${this.q('claimed_at')} bigint,\n        ${this.q('created_at')} bigint NOT NULL\n      )`,\n    );\n    await this.createIfMissing(\n      `CREATE TABLE IF NOT EXISTS ${this.q(this.runsTable)} (\n        ${this.q('run_id')} ${str} PRIMARY KEY,\n        ${this.q('ns')} ${str} NOT NULL,\n        ${this.q('priority')} integer NOT NULL,\n        ${this.q('wake')} integer NOT NULL,\n        ${this.q('claimed_by')} ${str},\n        ${this.q('claim_token')} ${str},\n        ${this.q('claimed_at')} bigint,\n        ${this.q('created_at')} bigint NOT NULL\n      )`,\n    );\n    await this.exec\n      .query(\n        `CREATE INDEX ${this.q(`${this.runsTable}_ns_idx`)} ON ${this.q(this.runsTable)} (${this.q('ns')}, ${this.q('priority')}, ${this.q('created_at')})`,\n      )\n      .catch(() => {});\n    // Best-effort index for the group poll (MySQL has no CREATE INDEX IF NOT EXISTS < 8.0.13).\n    await this.exec\n      .query(\n        `CREATE INDEX ${this.q(`${this.tasksTable}_grp_idx`)} ON ${tasks} (${this.q('grp')}, ${this.q('status')}, ${this.q('created_at')})`,\n      )\n      .catch(() => {});\n  }\n\n  // ── engine → worker ────────────────────────────────────────────────────────────────────────\n  async dispatch(task: RemoteTask): Promise<void> {\n    await this.ensureSchema();\n    const t = this.q(this.tasksTable);\n    // Idempotent: a redelivered dispatch for the same step_id is ignored (the row already exists).\n    const ignore = this.isPg\n      ? `INSERT INTO ${t} (...) ON CONFLICT (${this.q('step_id')}) DO NOTHING`\n      : `INSERT IGNORE INTO ${t} (...)`;\n    const cols = [\n      'step_id',\n      'run_id',\n      'seq',\n      'name',\n      'grp',\n      'input',\n      'attempt',\n      'status',\n      'created_at',\n    ];\n    const sql = ignore.replace(\n      '(...)',\n      `(${cols.map((c) => this.q(c)).join(', ')}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(', ')})`,\n    );\n    await this.exec.query(sql, [\n      task.stepId,\n      task.runId,\n      task.seq,\n      task.name,\n      task.group,\n      JSON.stringify(task.input ?? null),\n      task.attempt,\n      'pending',\n      this.now(),\n    ]);\n  }\n\n  // ── worker → engine ────────────────────────────────────────────────────────────────────────\n  handle(name: string, fn: StepHandler): void {\n    if (!this.group) throw new Error('DbTransport needs a `group` to register handlers');\n    this.handlers.set(name, fn);\n    if (!this.taskLoop) this.taskLoop = this.loop(() => this.drainTasks(this.group as string));\n  }\n\n  onResult(handler: (result: StepResult) => Promise<void>): void {\n    if (!this.resultLoop) this.resultLoop = this.loop(() => this.drainResults(handler));\n  }\n\n  onHeartbeat(_handler: (beat: Heartbeat) => Promise<void>): void {\n    // Not modelled; the lease/reclaim on `claimed_at` is the liveness mechanism.\n  }\n\n  // ── run queue (engine ↔ engine) ─────────────────────────────────────────────────────────────\n  /**\n   * Queue `pending` runs for whichever engine instance polls the run queue first: one row per run,\n   * keyed by run id, so a run already waiting is not queued twice. A run whose row an instance holds\n   * right now is released for another take, so a dispatch landing while the run's previous entry is\n   * being handled is not lost when that entry is deleted. Up to {@link RUNS_INSERT_CHUNK} rows per\n   * insert.\n   */\n  async dispatchRuns(runs: readonly RunDispatch[], opts?: RunQueueOptions): Promise<void> {\n    if (runs.length === 0) return;\n    await this.ensureSchema();\n    // One row per run (an upsert may not touch the same row twice in one statement); a wake among\n    // a run's dispatches makes its row a wake.\n    const byRun = new Map<string, RunDispatch>();\n    for (const run of runs) {\n      if (!byRun.has(run.runId) || run.reason === 'wake') byRun.set(run.runId, run);\n    }\n    const unique = [...byRun.values()];\n    const t = this.q(this.runsTable);\n    const cols = ['run_id', 'ns', 'priority', 'wake', 'created_at'];\n    const now = this.now();\n    for (let at = 0; at < unique.length; at += RUNS_INSERT_CHUNK) {\n      const chunk = unique.slice(at, at + RUNS_INSERT_CHUNK);\n      const values = chunk\n        .map((_, r) => `(${cols.map((__, c) => this.ph(r * cols.length + c + 1)).join(', ')})`)\n        .join(', ');\n      const insert = `INTO ${t} (${cols.map((c) => this.q(c)).join(', ')}) VALUES ${values}`;\n      const release = ['claimed_by', 'claim_token', 'claimed_at']\n        .map((c) => `${this.q(c)} = NULL`)\n        .join(', ');\n      const wake = this.q('wake');\n      const sql = this.isPg\n        ? `INSERT ${insert} ON CONFLICT (${this.q('run_id')}) DO UPDATE SET ${release}, ${wake} = GREATEST(${t}.${wake}, EXCLUDED.${wake})`\n        : `INSERT ${insert} ON DUPLICATE KEY UPDATE ${release}, ${wake} = GREATEST(${wake}, VALUES(${wake}))`;\n      await this.exec.query(\n        sql,\n        chunk.flatMap((run, r) => [\n          run.runId,\n          opts?.namespace ?? '',\n          run.priority ?? 0,\n          run.reason === 'wake' ? 1 : 0,\n          now + r,\n        ]),\n      );\n    }\n  }\n\n  /**\n   * Poll the run queue, at most `opts.concurrency` runs in flight on this instance. Rows are claimed\n   * with `FOR UPDATE SKIP LOCKED` (instances never take the same run), highest priority then oldest\n   * first; a row is deleted once its handler settles, and its lease is renewed meanwhile, so a row is\n   * re-taken only after the instance holding it went down. The returned stop takes no more rows and\n   * resolves once the runs in flight settled.\n   */\n  onDispatchedRun(\n    handler: (run: RunDispatch) => Promise<void>,\n    opts: RunConsumerOptions,\n  ): () => Promise<void> {\n    const consumer: RunConsumer = {\n      stopped: false,\n      inflight: new Set(),\n      slotFreed: undefined,\n      loop: Promise.resolve(),\n    };\n    const concurrency = Math.max(1, Math.floor(opts.concurrency));\n    const ns = opts.namespace ?? '';\n    consumer.loop = this.consumeRuns(consumer, handler, concurrency, ns).catch((err) => {\n      this.onError(err);\n    });\n    this.runConsumers.add(consumer);\n    return () => this.stopRunConsumer(consumer);\n  }\n\n  private async stopRunConsumer(consumer: RunConsumer): Promise<void> {\n    consumer.stopped = true;\n    consumer.slotFreed?.();\n    await consumer.loop;\n    this.runConsumers.delete(consumer);\n  }\n\n  private async consumeRuns(\n    consumer: RunConsumer,\n    handler: (run: RunDispatch) => Promise<void>,\n    concurrency: number,\n    ns: string,\n  ): Promise<void> {\n    const renew = setInterval(\n      () => void this.renewRunLeases(consumer).catch(() => undefined),\n      Math.max(1_000, Math.floor(this.leaseMs / 3)),\n    );\n    renew.unref?.();\n    const settled = new Set<Promise<unknown>>();\n    try {\n      while (this.running && !consumer.stopped) {\n        const free = concurrency - consumer.inflight.size;\n        if (free <= 0) {\n          await new Promise<void>((resolve) => {\n            consumer.slotFreed = resolve;\n          });\n          consumer.slotFreed = undefined;\n          continue;\n        }\n        let rows: ClaimedRun[] = [];\n        try {\n          await this.ensureSchema();\n          rows = await this.claimRuns(ns, Math.min(free, RUNS_CLAIM_MAX));\n        } catch (err) {\n          if (this.running && !consumer.stopped) this.onError(err);\n        }\n        for (const { run, token } of rows) {\n          consumer.inflight.add(token);\n          const done = handler(run)\n            .catch(() => undefined)\n            .then(() =>\n              this.exec\n                .query(\n                  `DELETE FROM ${this.q(this.runsTable)} WHERE ${this.q('claim_token')} = ${this.ph(1)}`,\n                  [token],\n                )\n                .catch(() => undefined),\n            )\n            .finally(() => {\n              consumer.inflight.delete(token);\n              settled.delete(done);\n              consumer.slotFreed?.();\n            });\n          settled.add(done);\n        }\n        if (rows.length === 0) await this.sleep(this.pollMs);\n      }\n      await Promise.allSettled([...settled]);\n    } finally {\n      clearInterval(renew);\n    }\n  }\n\n  private async claimRuns(ns: string, limit: number): Promise<ClaimedRun[]> {\n    const t = this.q(this.runsTable);\n    const staleBefore = this.now() - this.leaseMs;\n    return this.exec.transaction(async (tx) => {\n      const rows = await tx.query<RunRow>(\n        `SELECT ${this.q('run_id')}, ${this.q('wake')} FROM ${t}\n         WHERE ${this.q('ns')} = ${this.ph(1)}\n           AND (${this.q('claimed_at')} IS NULL OR ${this.q('claimed_at')} < ${this.ph(2)})\n         ORDER BY ${this.q('priority')} DESC, ${this.q('created_at')} ASC\n         LIMIT ${Math.floor(limit)} FOR UPDATE SKIP LOCKED`,\n        [ns, staleBefore],\n      );\n      const claimed = rows.map((r) => ({\n        run: {\n          runId: r.run_id,\n          reason: Number(r.wake) === 1 ? ('wake' as const) : ('start' as const),\n        },\n        token: globalThis.crypto.randomUUID(),\n      }));\n      const now = this.now();\n      for (const {\n        run: { runId },\n        token,\n      } of claimed) {\n        await tx.query(\n          `UPDATE ${t} SET ${this.q('claimed_by')} = ${this.ph(1)}, ${this.q('claim_token')} = ${this.ph(2)}, ${this.q('claimed_at')} = ${this.ph(3)}\n           WHERE ${this.q('run_id')} = ${this.ph(4)}`,\n          [this.instanceId, token, now, runId],\n        );\n      }\n      return claimed;\n    });\n  }\n\n  /** Keep the rows of the runs in flight leased, so a long turn is not re-taken by another instance. */\n  private async renewRunLeases(consumer: RunConsumer): Promise<void> {\n    const tokens = [...consumer.inflight];\n    if (tokens.length === 0) return;\n    await this.exec.query(\n      `UPDATE ${this.q(this.runsTable)} SET ${this.q('claimed_at')} = ${this.ph(1)}\n       WHERE ${this.q('claim_token')} IN (${tokens.map((_, i) => this.ph(i + 2)).join(', ')})`,\n      [this.now(), ...tokens],\n    );\n  }\n\n  // ── polling ──────────────────────────────────────────────────────────────────────────────────\n  /** Run `tick` repeatedly; sleep `pollMs` when it reports an empty queue. Stops on `close()`. */\n  private async loop(tick: () => Promise<number>): Promise<void> {\n    while (this.running) {\n      let processed = 0;\n      try {\n        await this.ensureSchema();\n        processed = await tick();\n      } catch (err) {\n        if (this.running) this.onError(err);\n      }\n      if (processed === 0 && this.running) await this.sleep(this.pollMs);\n    }\n  }\n\n  /**\n   * One task-loop round: claim as many rows as there are free slots (never more — a claimed row that\n   * isn't running is one an idle sibling can't run), and start each. With every slot busy, wait for\n   * one to free instead of polling.\n   */\n  private async drainTasks(group: string): Promise<number> {\n    const free = this.concurrency - this.runningTasks.size;\n    if (free <= 0) {\n      await Promise.race(this.runningTasks);\n      return 1;\n    }\n    const { rows, token } = await this.claim<TaskRow>(\n      this.tasksTable,\n      Math.min(free, this.batchSize),\n      `${this.q('grp')} = ${this.ph(1)}`,\n      [group],\n    );\n    if (rows.length === 0) return 0;\n    this.hold(this.tasksTable, token);\n    let left = rows.length;\n    for (const row of rows) {\n      const run = this.runTask(row, group, token).finally(() => {\n        this.runningTasks.delete(run);\n        left -= 1;\n        if (left === 0) this.release(this.tasksTable, token);\n      });\n      this.runningTasks.add(run);\n    }\n    return rows.length;\n  }\n\n  /**\n   * Run one claimed task and settle it — only while this instance still holds the claim: the claim is\n   * re-checked before running, and the task row is deleted and its result written in ONE transaction,\n   * conditional on the claim token, so an instance whose claim was taken over neither deletes the new\n   * holder's row nor publishes a second result.\n   */\n  private async runTask(row: TaskRow, group: string, token: string): Promise<void> {\n    try {\n      if (!(await this.stillHolds(row.step_id, token))) {\n        this.onError(\n          new Error(\n            `[DbTransport] lost the claim on task ${row.step_id} before running it — another instance took it over; not running it here`,\n          ),\n        );\n        return;\n      }\n      const task: RemoteTask = {\n        runId: row.run_id,\n        seq: Number(row.seq),\n        stepId: row.step_id,\n        name: row.name,\n        group,\n        input: row.input == null ? undefined : JSON.parse(row.input),\n        attempt: Number(row.attempt),\n      };\n      const result = await runStepHandler(task, this.handlers.get(task.name));\n      if (!(await this.settleTask(task.stepId, token, result))) {\n        this.onError(\n          new Error(\n            `[DbTransport] lost the claim on task ${task.stepId} while running it (this instance went silent past leaseMs) — another instance took it over and may run it too; this run's result was dropped. Raise leaseMs if steps block the event loop`,\n          ),\n        );\n      }\n    } catch (err) {\n      // A database error settling the row (or a malformed row): it stays claimed, stops being\n      // renewed, and is reclaimed after the lease — at-least-once, like a crash.\n      this.onError(err);\n    }\n  }\n\n  /** Whether the claim on `stepId` is still `token`'s (re-stamping it if so). */\n  private async stillHolds(stepId: string, token: string): Promise<boolean> {\n    const t = this.q(this.tasksTable);\n    const rows = await this.exec.transaction(async (tx) => {\n      const held = await tx.query<{ step_id: string }>(\n        `SELECT ${this.q('step_id')} FROM ${t} WHERE ${this.q('step_id')} = ${this.ph(1)} AND ${this.q('claimed_by')} = ${this.ph(2)} FOR UPDATE`,\n        [stepId, token],\n      );\n      if (held.length > 0) {\n        await tx.query(\n          `UPDATE ${t} SET ${this.q('claimed_at')} = ${this.ph(1)} WHERE ${this.q('step_id')} = ${this.ph(2)} AND ${this.q('claimed_by')} = ${this.ph(3)}`,\n          [this.now(), stepId, token],\n        );\n      }\n      return held;\n    });\n    return rows.length > 0;\n  }\n\n  /** Delete the task row and publish its result in ONE transaction, only while `token` holds it. */\n  private async settleTask(stepId: string, token: string, result: StepResult): Promise<boolean> {\n    const t = this.q(this.tasksTable);\n    return this.exec.transaction(async (tx) => {\n      const held = await tx.query<{ step_id: string }>(\n        `SELECT ${this.q('step_id')} FROM ${t} WHERE ${this.q('step_id')} = ${this.ph(1)} AND ${this.q('claimed_by')} = ${this.ph(2)} FOR UPDATE`,\n        [stepId, token],\n      );\n      if (held.length === 0) return false;\n      await tx.query(\n        `DELETE FROM ${t} WHERE ${this.q('step_id')} = ${this.ph(1)} AND ${this.q('claimed_by')} = ${this.ph(2)}`,\n        [stepId, token],\n      );\n      await this.insertResult(result, tx);\n      return true;\n    });\n  }\n\n  /**\n   * Claim a batch of results, deliver each to the engine, and delete it — only after its handler ran\n   * (at-least-once), and only while this round still holds the claim (a newer result for the same\n   * step that replaced the row resets the claim, so it is delivered next instead of deleted). The\n   * batch's claim is renewed until it is done. A throwing handler is reported and its row left for\n   * re-delivery after the lease; the rest of the batch continues.\n   */\n  private async drainResults(handler: (result: StepResult) => Promise<void>): Promise<number> {\n    const { rows, token } = await this.claim<ResultRow>(\n      this.resultsTable,\n      this.batchSize,\n      '1 = 1',\n      [],\n    );\n    if (rows.length === 0) return 0;\n    this.hold(this.resultsTable, token);\n    try {\n      for (const row of rows) {\n        if (!this.running) break;\n        try {\n          const result: StepResult = {\n            runId: row.run_id,\n            seq: Number(row.seq),\n            stepId: row.step_id,\n            status: row.status as StepResult['status'],\n            output: row.output == null ? undefined : JSON.parse(row.output),\n            error: row.error == null ? undefined : JSON.parse(row.error),\n            startedAt: row.started_at == null ? undefined : Number(row.started_at),\n          };\n          await handler(result);\n          await this.exec.query(\n            `DELETE FROM ${this.q(this.resultsTable)} WHERE ${this.q('step_id')} = ${this.ph(1)} AND ${this.q('claimed_by')} = ${this.ph(2)}`,\n            [row.step_id, token],\n          );\n        } catch (err) {\n          this.onError(err);\n        }\n      }\n    } finally {\n      this.release(this.resultsTable, token);\n    }\n    return rows.length;\n  }\n\n  /**\n   * Atomically claim up to `limit` un-leased rows matching `where` and stamp them with a claim token\n   * unique to this round (`<instanceId>:<uuid>`). `SELECT … FOR UPDATE SKIP LOCKED` inside the txn\n   * means concurrent instances skip each other's locked rows instead of blocking, so no row is\n   * claimed twice; the token is what every later delete/settle is conditional on.\n   */\n  private async claim<T extends { step_id: string }>(\n    table: string,\n    limit: number,\n    where: string,\n    whereParams: unknown[],\n  ): Promise<{ rows: T[]; token: string }> {\n    const t = this.q(table);\n    const staleBefore = this.now() - this.leaseMs;\n    const token = `${this.instanceId}:${randomUUID()}`;\n    const rows = await this.exec.transaction(async (tx) => {\n      const leaseClause = `(${this.q('claimed_at')} IS NULL OR ${this.q('claimed_at')} < ${this.ph(whereParams.length + 1)})`;\n      const found = await tx.query<T>(\n        `SELECT * FROM ${t} WHERE ${where} AND ${leaseClause}\n         ORDER BY ${this.q('created_at')} ASC LIMIT ${Math.max(1, Math.floor(limit))} FOR UPDATE SKIP LOCKED`,\n        [...whereParams, staleBefore],\n      );\n      if (found.length > 0) {\n        const ids = found.map((r) => r.step_id);\n        const placeholders = ids.map((_, i) => this.ph(i + 3)).join(', ');\n        await tx.query(\n          `UPDATE ${t} SET ${this.q('claimed_by')} = ${this.ph(1)}, ${this.q('claimed_at')} = ${this.ph(2)}\n           WHERE ${this.q('step_id')} IN (${placeholders})`,\n          [token, this.now(), ...ids],\n        );\n      }\n      return found;\n    });\n    return { rows, token };\n  }\n\n  // ── claim renewal: every claim held, not only the row being run ─────────────────────────────\n  private hold(table: string, token: string): void {\n    let tokens = this.held.get(table);\n    if (!tokens) {\n      tokens = new Set();\n      this.held.set(table, tokens);\n    }\n    tokens.add(token);\n    if (this.renewTimer) return;\n    const intervalMs = Math.max(10, Math.floor(this.leaseMs / 3));\n    this.renewTimer = setInterval(() => {\n      if (this.renewal) return; // a slow database never stacks renewal rounds\n      const round = this.renewHeld()\n        .catch((err) => this.onError(err))\n        .finally(() => {\n          if (this.renewal === round) this.renewal = undefined;\n        });\n      this.renewal = round;\n    }, intervalMs);\n    this.renewTimer.unref?.();\n  }\n\n  private release(table: string, token: string): void {\n    const tokens = this.held.get(table);\n    tokens?.delete(token);\n    if (tokens?.size === 0) this.held.delete(table);\n    if (this.held.size === 0 && this.renewTimer) {\n      clearInterval(this.renewTimer);\n      this.renewTimer = undefined;\n    }\n  }\n\n  /** Re-stamp `claimed_at` on every row still claimed under a token this instance holds. */\n  private async renewHeld(): Promise<void> {\n    for (const [table, tokens] of this.held) {\n      if (tokens.size === 0) continue;\n      const list = [...tokens];\n      const placeholders = list.map((_, i) => this.ph(i + 2)).join(', ');\n      await this.exec.query(\n        `UPDATE ${this.q(table)} SET ${this.q('claimed_at')} = ${this.ph(1)} WHERE ${this.q('claimed_by')} IN (${placeholders})`,\n        [this.now(), ...list],\n      );\n    }\n  }\n\n  /**\n   * Write a result row. A result already waiting for the same step (an earlier attempt's, not yet\n   * deleted by the engine) is REPLACED and its claim reset, never kept: `step_id` is stable across\n   * attempts, so keeping the old row would silently drop a retry's result.\n   */\n  private async insertResult(result: StepResult, tx: SqlTx = this.exec): Promise<void> {\n    const t = this.q(this.resultsTable);\n    const cols = [\n      'step_id',\n      'run_id',\n      'seq',\n      'status',\n      'output',\n      'error',\n      'started_at',\n      'created_at',\n    ];\n    const replace = ['run_id', 'seq', 'status', 'output', 'error', 'started_at', 'created_at'];\n    const values = `(${cols.map((c) => this.q(c)).join(', ')}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(', ')})`;\n    const sql = this.isPg\n      ? `INSERT INTO ${t} ${values} ON CONFLICT (${this.q('step_id')}) DO UPDATE SET ${[\n          ...replace.map((c) => `${this.q(c)} = EXCLUDED.${this.q(c)}`),\n          `${this.q('claimed_by')} = NULL`,\n          `${this.q('claimed_at')} = NULL`,\n        ].join(', ')}`\n      : `INSERT INTO ${t} ${values} ON DUPLICATE KEY UPDATE ${[\n          ...replace.map((c) => `${this.q(c)} = VALUES(${this.q(c)})`),\n          `${this.q('claimed_by')} = NULL`,\n          `${this.q('claimed_at')} = NULL`,\n        ].join(', ')}`;\n    await tx.query(sql, [\n      result.stepId,\n      result.runId,\n      result.seq,\n      result.status,\n      result.output === undefined ? null : JSON.stringify(result.output),\n      result.error === undefined ? null : JSON.stringify(result.error),\n      result.startedAt ?? null,\n      this.now(),\n    ]);\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise((r) => setTimeout(r, ms));\n  }\n\n  /** Stop the pollers and wait for the current ticks to settle. Does not close the shared DataSource. */\n  async close(): Promise<void> {\n    this.running = false;\n    await Promise.allSettled([\n      this.taskLoop,\n      this.resultLoop,\n      ...[...this.runConsumers].map((c) => this.stopRunConsumer(c)),\n    ]);\n    // Let running tasks settle (their claims keep being renewed until they do).\n    await Promise.allSettled([...this.runningTasks]);\n    if (this.renewTimer) clearInterval(this.renewTimer);\n    this.renewTimer = undefined;\n    await this.renewal;\n  }\n}\n","/**\n * The tiny SQL surface `DbTransport` needs, so it rides **whatever ORM/connection the app already\n * has** instead of forcing a specific one. Implement it for your ORM (adapters for TypeORM and\n * MikroORM ship below) and hand it to `new DbTransport({ executor })`. Mirrors how the durable\n * *store* is ORM-pluggable (store-typeorm / store-mikro-orm / …).\n */\nexport interface SqlExecutor {\n  /** Drives placeholder style (`$n` vs `?`) and a couple of DDL type choices. */\n  readonly dialect: 'mysql' | 'postgres';\n  /** Quote/escape an identifier (table/column name) for this dialect. */\n  escapeId(id: string): string;\n  /** Run a statement outside a transaction. */\n  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;\n  /** Run `fn` inside a transaction — the claim uses `FOR UPDATE SKIP LOCKED` within it. */\n  transaction<T>(fn: (tx: SqlTx) => Promise<T>): Promise<T>;\n}\n\nexport interface SqlTx {\n  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;\n}\n\n// ── TypeORM ──────────────────────────────────────────────────────────────────────────────────────\n\n/** Structural slice of a TypeORM `DataSource` — avoids a hard dependency on typeorm. */\ninterface TypeOrmDataSourceLike {\n  options: { type: string };\n  driver: { escape(id: string): string };\n  query(sql: string, params?: unknown[]): Promise<unknown>;\n  createQueryRunner(): {\n    connect(): Promise<void>;\n    startTransaction(): Promise<void>;\n    commitTransaction(): Promise<void>;\n    rollbackTransaction(): Promise<void>;\n    release(): Promise<void>;\n    query(sql: string, params?: unknown[]): Promise<unknown>;\n  };\n}\n\n/** Build an executor from a TypeORM `DataSource` (e.g. the one the durable store already uses). */\nexport function typeOrmExecutor(ds: TypeOrmDataSourceLike): SqlExecutor {\n  return {\n    dialect: /postgres/.test(String(ds.options.type)) ? 'postgres' : 'mysql',\n    escapeId: (id) => ds.driver.escape(id),\n    query: <T>(sql: string, params?: unknown[]) => ds.query(sql, params) as Promise<T[]>,\n    transaction: async <T>(fn: (tx: SqlTx) => Promise<T>) => {\n      const qr = ds.createQueryRunner();\n      await qr.connect();\n      await qr.startTransaction();\n      try {\n        const result = await fn({\n          query: <U>(sql: string, params?: unknown[]) => qr.query(sql, params) as Promise<U[]>,\n        });\n        await qr.commitTransaction();\n        return result;\n      } catch (err) {\n        await qr.rollbackTransaction();\n        throw err;\n      } finally {\n        await qr.release();\n      }\n    },\n  };\n}\n\n// ── MikroORM ─────────────────────────────────────────────────────────────────────────────────────\n\n/** Structural slice of a MikroORM `EntityManager` — avoids a hard dependency on @mikro-orm/core. */\ninterface MikroOrmEmLike {\n  getPlatform(): { constructor: { name: string }; quoteIdentifier(id: string): string };\n  getConnection(): {\n    execute(sql: string, params?: unknown[], method?: 'all', ctx?: unknown): Promise<unknown>;\n  };\n  getTransactionContext?(): unknown;\n  transactional<T>(cb: (em: MikroOrmEmLike) => Promise<T>): Promise<T>;\n}\n\n/**\n * Build an executor from a MikroORM `EntityManager` — i.e. **the app's own configured ORM**. Runs\n * raw SQL through `em.getConnection().execute(...)` and wraps the claim in `em.transactional(...)`,\n * threading the transaction context so `FOR UPDATE SKIP LOCKED` locks within the tx.\n */\nexport function mikroOrmExecutor(em: MikroOrmEmLike): SqlExecutor {\n  const platform = em.getPlatform();\n  return {\n    dialect: /postgre/i.test(platform.constructor.name) ? 'postgres' : 'mysql',\n    escapeId: (id) => platform.quoteIdentifier(id),\n    query: <T>(sql: string, params?: unknown[]) =>\n      em.getConnection().execute(sql, params ?? [], 'all') as Promise<T[]>,\n    transaction: <T>(fn: (tx: SqlTx) => Promise<T>) =>\n      em.transactional((txEm) =>\n        fn({\n          query: <U>(sql: string, params?: unknown[]) =>\n            txEm\n              .getConnection()\n              .execute(sql, params ?? [], 'all', txEm.getTransactionContext?.()) as Promise<U[]>,\n        }),\n      ),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;ACAA,yBAA2B;AAC3B,iCAUO;;;AC4BA,SAASA,gBAAgBC,IAAyB;AACvD,SAAO;IACLC,SAAS,WAAWC,KAAKC,OAAOH,GAAGI,QAAQC,IAAI,CAAA,IAAK,aAAa;IACjEC,UAAU,wBAACC,OAAOP,GAAGQ,OAAOC,OAAOF,EAAAA,GAAzB;IACVG,OAAO,wBAAIC,KAAaC,WAAuBZ,GAAGU,MAAMC,KAAKC,MAAAA,GAAtD;IACPC,aAAa,8BAAUC,OAAAA;AACrB,YAAMC,KAAKf,GAAGgB,kBAAiB;AAC/B,YAAMD,GAAGE,QAAO;AAChB,YAAMF,GAAGG,iBAAgB;AACzB,UAAI;AACF,cAAMC,SAAS,MAAML,GAAG;UACtBJ,OAAO,wBAAIC,KAAaC,WAAuBG,GAAGL,MAAMC,KAAKC,MAAAA,GAAtD;QACT,CAAA;AACA,cAAMG,GAAGK,kBAAiB;AAC1B,eAAOD;MACT,SAASE,KAAK;AACZ,cAAMN,GAAGO,oBAAmB;AAC5B,cAAMD;MACR,UAAA;AACE,cAAMN,GAAGQ,QAAO;MAClB;IACF,GAhBa;EAiBf;AACF;AAvBgBxB;AA0CT,SAASyB,iBAAiBC,IAAkB;AACjD,QAAMC,WAAWD,GAAGE,YAAW;AAC/B,SAAO;IACL1B,SAAS,WAAWC,KAAKwB,SAAS,YAAYE,IAAI,IAAI,aAAa;IACnEtB,UAAU,wBAACC,OAAOmB,SAASG,gBAAgBtB,EAAAA,GAAjC;IACVG,OAAO,wBAAIC,KAAaC,WACtBa,GAAGK,cAAa,EAAGC,QAAQpB,KAAKC,UAAU,CAAA,GAAI,KAAA,GADzC;IAEPC,aAAa,wBAAIC,OACfW,GAAGO,cAAc,CAACC,SAChBnB,GAAG;MACDJ,OAAO,wBAAIC,KAAaC,WACtBqB,KACGH,cAAa,EACbC,QAAQpB,KAAKC,UAAU,CAAA,GAAI,OAAOqB,KAAKC,wBAAqB,CAAA,GAH1D;IAIT,CAAA,CAAA,GAPS;EASf;AACF;AAjBgBV;;;AD5ChB,IAAMW,oBAAoB;AAE1B,IAAMC,iBAAiB;AAqEvB,SAASC,aAAaC,OAA2BC,UAAkBC,KAAW;AAC5E,SAAOF,UAAUG,UAAaC,OAAOC,SAASL,KAAAA,KAAUA,SAASE,MAAMF,QAAQC;AACjF;AAFSF;AAiBF,IAAMO,cAAN,MAAMA;EA7Hb,OA6HaA;;;EACMC;EACAC;EACAC;EACAC;EACAC;EACAC,eAAe,oBAAIC,IAAAA;EACnBC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EAEAC,WAAW,oBAAIC,IAAAA;EACxBC,UAAU;EACVC;EACAC;EACAC;;EAESC,eAAe,oBAAIf,IAAAA;;EAEnBgB,OAAO,oBAAIN,IAAAA;EACpBO;EACAC;EAER,YAAYC,SAA6B;AACvC,SAAKzB,OAAOyB,QAAQC;AACpB,SAAKzB,QAAQwB,QAAQxB;AACrB,UAAM0B,SAASF,QAAQE,UAAU;AACjC,SAAKzB,aAAa,GAAGyB,MAAAA;AACrB,SAAKxB,eAAe,GAAGwB,MAAAA;AACvB,SAAKvB,YAAY,GAAGuB,MAAAA;AACpB,SAAKpB,SAASf,aAAaiC,QAAQlB,QAAQ,KAAK,CAAA;AAChD,SAAKC,UAAUhB,aAAaiC,QAAQjB,SAAS,KAAQ,CAAA;AACrD,SAAKC,YAAYmB,KAAKC,MAAMrC,aAAaiC,QAAQhB,WAAW,IAAI,CAAA,CAAA;AAChE,SAAKC,cAAckB,KAAKC,MAAMrC,aAAaiC,QAAQf,aAAa,GAAG,CAAA,CAAA;AACnE,SAAKC,UAAUc,QAAQd,YAAY,CAACmB,QAAQC,QAAQC,MAAM,iBAAiBF,GAAAA;AAC3E,SAAKlB,aAAaa,QAAQb,cAAc;AAExC,SAAKC,aAAaY,QAAQZ,cAAc,UAAMoB,+BAAAA,CAAAA;AAC9C,SAAKnB,OAAO,KAAKd,KAAKkC,YAAY;EACpC;;;EAIQC,GAAGC,GAAmB;AAC5B,WAAO,KAAKtB,OAAO,IAAIsB,CAAAA,KAAM;EAC/B;EACQC,EAAEC,IAAoB;AAC5B,WAAO,KAAKtC,KAAKuC,SAASD,EAAAA;EAC5B;EACQE,MAAc;AACpB,WAAOZ,KAAKC,MAAMY,KAAKD,IAAG,CAAA;EAC5B;;EAGQE,eAA8B;AACpC,QAAI,CAAC,KAAKxB,aAAa;AAErB,WAAKA,cAAc,KAAKyB,aAAY,EAAGC,MAAM,CAACd,QAAAA;AAC5C,aAAKZ,cAActB;AACnB,cAAMkC;MACR,CAAA;IACF;AACA,WAAO,KAAKZ;EACd;;;;;;EAOA,MAAc2B,gBAAgBC,KAA4B;AACxD,QAAI;AACF,YAAM,KAAK9C,KAAK+C,MAAMD,GAAAA;IACxB,QAAQ;AACN,YAAM,KAAK9C,KAAK+C,MAAMD,GAAAA;IACxB;EACF;EAEA,MAAcH,eAA8B;AAC1C,QAAI,CAAC,KAAK/B,WAAY;AACtB,UAAMoC,MAAM;AACZ,UAAMC,MAAM,KAAKnC,OAAO,SAAS;AACjC,UAAMoC,QAAQ,KAAKb,EAAE,KAAKnC,UAAU;AACpC,UAAMiD,UAAU,KAAKd,EAAE,KAAKlC,YAAY;AACxC,UAAM,KAAK0C,gBACT,8BAA8BK,KAAAA;UAC1B,KAAKb,EAAE,SAAA,CAAA,IAAcW,GAAAA;UACrB,KAAKX,EAAE,QAAA,CAAA,IAAaW,GAAAA;UACpB,KAAKX,EAAE,KAAA,CAAA;UACP,KAAKA,EAAE,MAAA,CAAA,IAAWW,GAAAA;UAClB,KAAKX,EAAE,KAAA,CAAA,IAAUW,GAAAA;UACjB,KAAKX,EAAE,OAAA,CAAA,IAAYY,GAAAA;UACnB,KAAKZ,EAAE,SAAA,CAAA;UACP,KAAKA,EAAE,QAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA,IAAiBW,GAAAA;UACxB,KAAKX,EAAE,YAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA;QACT;AAEJ,UAAM,KAAKQ,gBACT,8BAA8BM,OAAAA;UAC1B,KAAKd,EAAE,SAAA,CAAA,IAAcW,GAAAA;UACrB,KAAKX,EAAE,QAAA,CAAA,IAAaW,GAAAA;UACpB,KAAKX,EAAE,KAAA,CAAA;UACP,KAAKA,EAAE,QAAA,CAAA;UACP,KAAKA,EAAE,QAAA,CAAA,IAAaY,GAAAA;UACpB,KAAKZ,EAAE,OAAA,CAAA,IAAYY,GAAAA;UACnB,KAAKZ,EAAE,YAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA,IAAiBW,GAAAA;UACxB,KAAKX,EAAE,YAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA;QACT;AAEJ,UAAM,KAAKQ,gBACT,8BAA8B,KAAKR,EAAE,KAAKjC,SAAS,CAAA;UAC/C,KAAKiC,EAAE,QAAA,CAAA,IAAaW,GAAAA;UACpB,KAAKX,EAAE,IAAA,CAAA,IAASW,GAAAA;UAChB,KAAKX,EAAE,UAAA,CAAA;UACP,KAAKA,EAAE,MAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA,IAAiBW,GAAAA;UACxB,KAAKX,EAAE,aAAA,CAAA,IAAkBW,GAAAA;UACzB,KAAKX,EAAE,YAAA,CAAA;UACP,KAAKA,EAAE,YAAA,CAAA;QACT;AAEJ,UAAM,KAAKrC,KACR+C,MACC,gBAAgB,KAAKV,EAAE,GAAG,KAAKjC,SAAS,SAAS,CAAA,OAAQ,KAAKiC,EAAE,KAAKjC,SAAS,CAAA,KAAM,KAAKiC,EAAE,IAAA,CAAA,KAAU,KAAKA,EAAE,UAAA,CAAA,KAAgB,KAAKA,EAAE,YAAA,CAAA,GAAgB,EAEpJO,MAAM,MAAA;IAAO,CAAA;AAEhB,UAAM,KAAK5C,KACR+C,MACC,gBAAgB,KAAKV,EAAE,GAAG,KAAKnC,UAAU,UAAU,CAAA,OAAQgD,KAAAA,KAAU,KAAKb,EAAE,KAAA,CAAA,KAAW,KAAKA,EAAE,QAAA,CAAA,KAAc,KAAKA,EAAE,YAAA,CAAA,GAAgB,EAEpIO,MAAM,MAAA;IAAO,CAAA;EAClB;;EAGA,MAAMQ,SAASC,MAAiC;AAC9C,UAAM,KAAKX,aAAY;AACvB,UAAMY,IAAI,KAAKjB,EAAE,KAAKnC,UAAU;AAEhC,UAAMqD,SAAS,KAAKzC,OAChB,eAAewC,CAAAA,uBAAwB,KAAKjB,EAAE,SAAA,CAAA,iBAC9C,sBAAsBiB,CAAAA;AAC1B,UAAME,OAAO;MACX;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;;AAEF,UAAMV,MAAMS,OAAOE,QACjB,SACA,IAAID,KAAKE,IAAI,CAACC,MAAM,KAAKtB,EAAEsB,CAAAA,CAAAA,EAAIC,KAAK,IAAA,CAAA,aAAkBJ,KAAKE,IAAI,CAACG,GAAGzB,MAAM,KAAKD,GAAGC,IAAI,CAAA,CAAA,EAAIwB,KAAK,IAAA,CAAA,GAAQ;AAExG,UAAM,KAAK5D,KAAK+C,MAAMD,KAAK;MACzBO,KAAKS;MACLT,KAAKU;MACLV,KAAKW;MACLX,KAAKY;MACLZ,KAAKpD;MACLiE,KAAKC,UAAUd,KAAKe,SAAS,IAAA;MAC7Bf,KAAKgB;MACL;MACA,KAAK7B,IAAG;KACT;EACH;;EAGA8B,OAAOL,MAAcM,IAAuB;AAC1C,QAAI,CAAC,KAAKtE,MAAO,OAAM,IAAIuE,MAAM,kDAAA;AACjC,SAAKzD,SAAS0D,IAAIR,MAAMM,EAAAA;AACxB,QAAI,CAAC,KAAKpD,SAAU,MAAKA,WAAW,KAAKuD,KAAK,MAAM,KAAKC,WAAW,KAAK1E,KAAK,CAAA;EAChF;EAEA2E,SAASC,SAAsD;AAC7D,QAAI,CAAC,KAAKzD,WAAY,MAAKA,aAAa,KAAKsD,KAAK,MAAM,KAAKI,aAAaD,OAAAA,CAAAA;EAC5E;EAEAE,YAAYC,UAAoD;EAEhE;;;;;;;;;EAUA,MAAMC,aAAaC,MAA8BC,MAAuC;AACtF,QAAID,KAAKE,WAAW,EAAG;AACvB,UAAM,KAAK1C,aAAY;AAGvB,UAAM2C,QAAQ,oBAAIrE,IAAAA;AAClB,eAAWsE,OAAOJ,MAAM;AACtB,UAAI,CAACG,MAAME,IAAID,IAAIvB,KAAK,KAAKuB,IAAIE,WAAW,OAAQH,OAAMZ,IAAIa,IAAIvB,OAAOuB,GAAAA;IAC3E;AACA,UAAMG,SAAS;SAAIJ,MAAMK,OAAM;;AAC/B,UAAMpC,IAAI,KAAKjB,EAAE,KAAKjC,SAAS;AAC/B,UAAMoD,OAAO;MAAC;MAAU;MAAM;MAAY;MAAQ;;AAClD,UAAMhB,MAAM,KAAKA,IAAG;AACpB,aAASmD,KAAK,GAAGA,KAAKF,OAAOL,QAAQO,MAAMrG,mBAAmB;AAC5D,YAAMsG,QAAQH,OAAOI,MAAMF,IAAIA,KAAKrG,iBAAAA;AACpC,YAAMoG,SAASE,MACZlC,IAAI,CAACG,GAAGiC,MAAM,IAAItC,KAAKE,IAAI,CAACqC,IAAIpC,MAAM,KAAKxB,GAAG2D,IAAItC,KAAK4B,SAASzB,IAAI,CAAA,CAAA,EAAIC,KAAK,IAAA,CAAA,GAAQ,EACrFA,KAAK,IAAA;AACR,YAAMoC,SAAS,QAAQ1C,CAAAA,KAAME,KAAKE,IAAI,CAACC,MAAM,KAAKtB,EAAEsB,CAAAA,CAAAA,EAAIC,KAAK,IAAA,CAAA,YAAiB8B,MAAAA;AAC9E,YAAMO,UAAU;QAAC;QAAc;QAAe;QAC3CvC,IAAI,CAACC,MAAM,GAAG,KAAKtB,EAAEsB,CAAAA,CAAAA,SAAW,EAChCC,KAAK,IAAA;AACR,YAAMsC,OAAO,KAAK7D,EAAE,MAAA;AACpB,YAAMS,MAAM,KAAKhC,OACb,UAAUkF,MAAAA,iBAAuB,KAAK3D,EAAE,QAAA,CAAA,mBAA4B4D,OAAAA,KAAYC,IAAAA,eAAmB5C,CAAAA,IAAK4C,IAAAA,cAAkBA,IAAAA,MAC1H,UAAUF,MAAAA,4BAAkCC,OAAAA,KAAYC,IAAAA,eAAmBA,IAAAA,YAAgBA,IAAAA;AAC/F,YAAM,KAAKlG,KAAK+C,MACdD,KACA8C,MAAMO,QAAQ,CAACb,KAAKQ,MAAM;QACxBR,IAAIvB;QACJoB,MAAMiB,aAAa;QACnBd,IAAIe,YAAY;QAChBf,IAAIE,WAAW,SAAS,IAAI;QAC5BhD,MAAMsD;OACP,CAAA;IAEL;EACF;;;;;;;;EASAQ,gBACEzB,SACAM,MACqB;AACrB,UAAMoB,WAAwB;MAC5BC,SAAS;MACTC,UAAU,oBAAInG,IAAAA;MACdoG,WAAW9G;MACX8E,MAAMiC,QAAQC,QAAO;IACvB;AACA,UAAMlG,cAAckB,KAAKiF,IAAI,GAAGjF,KAAKC,MAAMsD,KAAKzE,WAAW,CAAA;AAC3D,UAAMoG,KAAK3B,KAAKiB,aAAa;AAC7BG,aAAS7B,OAAO,KAAKqC,YAAYR,UAAU1B,SAASnE,aAAaoG,EAAAA,EAAIlE,MAAM,CAACd,QAAAA;AAC1E,WAAKnB,QAAQmB,GAAAA;IACf,CAAA;AACA,SAAKzB,aAAa2G,IAAIT,QAAAA;AACtB,WAAO,MAAM,KAAKU,gBAAgBV,QAAAA;EACpC;EAEA,MAAcU,gBAAgBV,UAAsC;AAClEA,aAASC,UAAU;AACnBD,aAASG,YAAS;AAClB,UAAMH,SAAS7B;AACf,SAAKrE,aAAa6G,OAAOX,QAAAA;EAC3B;EAEA,MAAcQ,YACZR,UACA1B,SACAnE,aACAoG,IACe;AACf,UAAMK,QAAQC,YACZ,MAAM,KAAK,KAAKC,eAAed,QAAAA,EAAU3D,MAAM,MAAMhD,MAAAA,GACrDgC,KAAKiF,IAAI,KAAOjF,KAAKC,MAAM,KAAKrB,UAAU,CAAA,CAAA,CAAA;AAE5C2G,UAAMG,QAAK;AACX,UAAMC,UAAU,oBAAIjH,IAAAA;AACpB,QAAI;AACF,aAAO,KAAKW,WAAW,CAACsF,SAASC,SAAS;AACxC,cAAMgB,OAAO9G,cAAc6F,SAASE,SAASgB;AAC7C,YAAID,QAAQ,GAAG;AACb,gBAAM,IAAIb,QAAc,CAACC,YAAAA;AACvBL,qBAASG,YAAYE;UACvB,CAAA;AACAL,mBAASG,YAAY9G;AACrB;QACF;AACA,YAAI8H,OAAqB,CAAA;AACzB,YAAI;AACF,gBAAM,KAAKhF,aAAY;AACvBgF,iBAAO,MAAM,KAAKC,UAAUb,IAAIlF,KAAKjC,IAAI6H,MAAMjI,cAAAA,CAAAA;QACjD,SAASuC,KAAK;AACZ,cAAI,KAAKb,WAAW,CAACsF,SAASC,QAAS,MAAK7F,QAAQmB,GAAAA;QACtD;AACA,mBAAW,EAAEwD,KAAKsC,MAAK,KAAMF,MAAM;AACjCnB,mBAASE,SAASO,IAAIY,KAAAA;AACtB,gBAAMC,OAAOhD,QAAQS,GAAAA,EAClB1C,MAAM,MAAMhD,MAAAA,EACZkI,KAAK,MACJ,KAAK9H,KACF+C,MACC,eAAe,KAAKV,EAAE,KAAKjC,SAAS,CAAA,UAAW,KAAKiC,EAAE,aAAA,CAAA,MAAoB,KAAKF,GAAG,CAAA,CAAA,IAClF;YAACyF;WAAM,EAERhF,MAAM,MAAMhD,MAAAA,CAAAA,EAEhBmI,QAAQ,MAAA;AACPxB,qBAASE,SAASS,OAAOU,KAAAA;AACzBL,oBAAQL,OAAOW,IAAAA;AACftB,qBAASG,YAAS;UACpB,CAAA;AACFa,kBAAQP,IAAIa,IAAAA;QACd;AACA,YAAIH,KAAKtC,WAAW,EAAG,OAAM,KAAK4C,MAAM,KAAKzH,MAAM;MACrD;AACA,YAAMoG,QAAQsB,WAAW;WAAIV;OAAQ;IACvC,UAAA;AACEW,oBAAcf,KAAAA;IAChB;EACF;EAEA,MAAcQ,UAAUb,IAAYqB,OAAsC;AACxE,UAAM7E,IAAI,KAAKjB,EAAE,KAAKjC,SAAS;AAC/B,UAAMgI,cAAc,KAAK5F,IAAG,IAAK,KAAKhC;AACtC,WAAO,KAAKR,KAAKqI,YAAY,OAAOC,OAAAA;AAClC,YAAMZ,OAAO,MAAMY,GAAGvF,MACpB,UAAU,KAAKV,EAAE,QAAA,CAAA,KAAc,KAAKA,EAAE,MAAA,CAAA,SAAgBiB,CAAAA;iBAC7C,KAAKjB,EAAE,IAAA,CAAA,MAAW,KAAKF,GAAG,CAAA,CAAA;kBACzB,KAAKE,EAAE,YAAA,CAAA,eAA4B,KAAKA,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA;oBACnE,KAAKE,EAAE,UAAA,CAAA,UAAqB,KAAKA,EAAE,YAAA,CAAA;iBACtCT,KAAKC,MAAMsG,KAAAA,CAAAA,2BACpB;QAACrB;QAAIsB;OAAY;AAEnB,YAAMG,UAAUb,KAAKhE,IAAI,CAACoC,OAAO;QAC/BR,KAAK;UACHvB,OAAO+B,EAAE0C;UACThD,QAAQ3F,OAAOiG,EAAEI,IAAI,MAAM,IAAK,SAAoB;QACtD;QACA0B,OAAOa,WAAWC,OAAOzG,WAAU;MACrC,EAAA;AACA,YAAMO,MAAM,KAAKA,IAAG;AACpB,iBAAW,EACT8C,KAAK,EAAEvB,MAAK,GACZ6D,MAAK,KACFW,SAAS;AACZ,cAAMD,GAAGvF,MACP,UAAUO,CAAAA,QAAS,KAAKjB,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,KAAO,KAAKE,EAAE,aAAA,CAAA,MAAoB,KAAKF,GAAG,CAAA,CAAA,KAAO,KAAKE,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA;mBAC/H,KAAKE,EAAE,QAAA,CAAA,MAAe,KAAKF,GAAG,CAAA,CAAA,IACvC;UAAC,KAAKtB;UAAY+G;UAAOpF;UAAKuB;SAAM;MAExC;AACA,aAAOwE;IACT,CAAA;EACF;;EAGA,MAAclB,eAAed,UAAsC;AACjE,UAAMoC,SAAS;SAAIpC,SAASE;;AAC5B,QAAIkC,OAAOvD,WAAW,EAAG;AACzB,UAAM,KAAKpF,KAAK+C,MACd,UAAU,KAAKV,EAAE,KAAKjC,SAAS,CAAA,QAAS,KAAKiC,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA;eACjE,KAAKE,EAAE,aAAA,CAAA,QAAsBsG,OAAOjF,IAAI,CAACG,GAAGzB,MAAM,KAAKD,GAAGC,IAAI,CAAA,CAAA,EAAIwB,KAAK,IAAA,CAAA,KAChF;MAAC,KAAKpB,IAAG;SAAOmG;KAAO;EAE3B;;;EAIA,MAAcjE,KAAKkE,MAA4C;AAC7D,WAAO,KAAK3H,SAAS;AACnB,UAAI4H,YAAY;AAChB,UAAI;AACF,cAAM,KAAKnG,aAAY;AACvBmG,oBAAY,MAAMD,KAAAA;MACpB,SAAS9G,KAAK;AACZ,YAAI,KAAKb,QAAS,MAAKN,QAAQmB,GAAAA;MACjC;AACA,UAAI+G,cAAc,KAAK,KAAK5H,QAAS,OAAM,KAAK+G,MAAM,KAAKzH,MAAM;IACnE;EACF;;;;;;EAOA,MAAcoE,WAAW1E,OAAgC;AACvD,UAAMuH,OAAO,KAAK9G,cAAc,KAAKW,aAAaoG;AAClD,QAAID,QAAQ,GAAG;AACb,YAAMb,QAAQmC,KAAK,KAAKzH,YAAY;AACpC,aAAO;IACT;AACA,UAAM,EAAEqG,MAAME,MAAK,IAAK,MAAM,KAAKmB,MACjC,KAAK7I,YACL0B,KAAKjC,IAAI6H,MAAM,KAAK/G,SAAS,GAC7B,GAAG,KAAK4B,EAAE,KAAA,CAAA,MAAY,KAAKF,GAAG,CAAA,CAAA,IAC9B;MAAClC;KAAM;AAET,QAAIyH,KAAKtC,WAAW,EAAG,QAAO;AAC9B,SAAK4D,KAAK,KAAK9I,YAAY0H,KAAAA;AAC3B,QAAIqB,OAAOvB,KAAKtC;AAChB,eAAW8D,OAAOxB,MAAM;AACtB,YAAMpC,MAAM,KAAK6D,QAAQD,KAAKjJ,OAAO2H,KAAAA,EAAOG,QAAQ,MAAA;AAClD,aAAK1G,aAAa6F,OAAO5B,GAAAA;AACzB2D,gBAAQ;AACR,YAAIA,SAAS,EAAG,MAAKhD,QAAQ,KAAK/F,YAAY0H,KAAAA;MAChD,CAAA;AACA,WAAKvG,aAAa2F,IAAI1B,GAAAA;IACxB;AACA,WAAOoC,KAAKtC;EACd;;;;;;;EAQA,MAAc+D,QAAQD,KAAcjJ,OAAe2H,OAA8B;AAC/E,QAAI;AACF,UAAI,CAAE,MAAM,KAAKwB,WAAWF,IAAIG,SAASzB,KAAAA,GAAS;AAChD,aAAKjH,QACH,IAAI6D,MACF,wCAAwC0E,IAAIG,OAAO,8EAAyE,CAAA;AAGhI;MACF;AACA,YAAMhG,OAAmB;QACvBU,OAAOmF,IAAIV;QACXxE,KAAKnE,OAAOqJ,IAAIlF,GAAG;QACnBF,QAAQoF,IAAIG;QACZpF,MAAMiF,IAAIjF;QACVhE;QACAmE,OAAO8E,IAAI9E,SAAS,OAAOxE,SAAYsE,KAAKoF,MAAMJ,IAAI9E,KAAK;QAC3DC,SAASxE,OAAOqJ,IAAI7E,OAAO;MAC7B;AACA,YAAMkF,SAAS,UAAMC,2CAAenG,MAAM,KAAKtC,SAAS0I,IAAIpG,KAAKY,IAAI,CAAA;AACrE,UAAI,CAAE,MAAM,KAAKyF,WAAWrG,KAAKS,QAAQ8D,OAAO2B,MAAAA,GAAU;AACxD,aAAK5I,QACH,IAAI6D,MACF,wCAAwCnB,KAAKS,MAAM,gMAA2L,CAAA;MAGpP;IACF,SAAShC,KAAK;AAGZ,WAAKnB,QAAQmB,GAAAA;IACf;EACF;;EAGA,MAAcsH,WAAWtF,QAAgB8D,OAAiC;AACxE,UAAMtE,IAAI,KAAKjB,EAAE,KAAKnC,UAAU;AAChC,UAAMwH,OAAO,MAAM,KAAK1H,KAAKqI,YAAY,OAAOC,OAAAA;AAC9C,YAAMhH,OAAO,MAAMgH,GAAGvF,MACpB,UAAU,KAAKV,EAAE,SAAA,CAAA,SAAmBiB,CAAAA,UAAW,KAAKjB,EAAE,SAAA,CAAA,MAAgB,KAAKF,GAAG,CAAA,CAAA,QAAU,KAAKE,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,eAC1H;QAAC2B;QAAQ8D;OAAM;AAEjB,UAAItG,KAAK8D,SAAS,GAAG;AACnB,cAAMkD,GAAGvF,MACP,UAAUO,CAAAA,QAAS,KAAKjB,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,UAAY,KAAKE,EAAE,SAAA,CAAA,MAAgB,KAAKF,GAAG,CAAA,CAAA,QAAU,KAAKE,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,IAC5I;UAAC,KAAKK,IAAG;UAAIsB;UAAQ8D;SAAM;MAE/B;AACA,aAAOtG;IACT,CAAA;AACA,WAAOoG,KAAKtC,SAAS;EACvB;;EAGA,MAAcsE,WAAW5F,QAAgB8D,OAAe2B,QAAsC;AAC5F,UAAMjG,IAAI,KAAKjB,EAAE,KAAKnC,UAAU;AAChC,WAAO,KAAKF,KAAKqI,YAAY,OAAOC,OAAAA;AAClC,YAAMhH,OAAO,MAAMgH,GAAGvF,MACpB,UAAU,KAAKV,EAAE,SAAA,CAAA,SAAmBiB,CAAAA,UAAW,KAAKjB,EAAE,SAAA,CAAA,MAAgB,KAAKF,GAAG,CAAA,CAAA,QAAU,KAAKE,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,eAC1H;QAAC2B;QAAQ8D;OAAM;AAEjB,UAAItG,KAAK8D,WAAW,EAAG,QAAO;AAC9B,YAAMkD,GAAGvF,MACP,eAAeO,CAAAA,UAAW,KAAKjB,EAAE,SAAA,CAAA,MAAgB,KAAKF,GAAG,CAAA,CAAA,QAAU,KAAKE,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,IACrG;QAAC2B;QAAQ8D;OAAM;AAEjB,YAAM,KAAK+B,aAAaJ,QAAQjB,EAAAA;AAChC,aAAO;IACT,CAAA;EACF;;;;;;;;EASA,MAAcxD,aAAaD,SAAiE;AAC1F,UAAM,EAAE6C,MAAME,MAAK,IAAK,MAAM,KAAKmB,MACjC,KAAK5I,cACL,KAAKM,WACL,SACA,CAAA,CAAE;AAEJ,QAAIiH,KAAKtC,WAAW,EAAG,QAAO;AAC9B,SAAK4D,KAAK,KAAK7I,cAAcyH,KAAAA;AAC7B,QAAI;AACF,iBAAWsB,OAAOxB,MAAM;AACtB,YAAI,CAAC,KAAKzG,QAAS;AACnB,YAAI;AACF,gBAAMsI,SAAqB;YACzBxF,OAAOmF,IAAIV;YACXxE,KAAKnE,OAAOqJ,IAAIlF,GAAG;YACnBF,QAAQoF,IAAIG;YACZO,QAAQV,IAAIU;YACZC,QAAQX,IAAIW,UAAU,OAAOjK,SAAYsE,KAAKoF,MAAMJ,IAAIW,MAAM;YAC9D7H,OAAOkH,IAAIlH,SAAS,OAAOpC,SAAYsE,KAAKoF,MAAMJ,IAAIlH,KAAK;YAC3D8H,WAAWZ,IAAIa,cAAc,OAAOnK,SAAYC,OAAOqJ,IAAIa,UAAU;UACvE;AACA,gBAAMlF,QAAQ0E,MAAAA;AACd,gBAAM,KAAKvJ,KAAK+C,MACd,eAAe,KAAKV,EAAE,KAAKlC,YAAY,CAAA,UAAW,KAAKkC,EAAE,SAAA,CAAA,MAAgB,KAAKF,GAAG,CAAA,CAAA,QAAU,KAAKE,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,IAC7H;YAAC+G,IAAIG;YAASzB;WAAM;QAExB,SAAS9F,KAAK;AACZ,eAAKnB,QAAQmB,GAAAA;QACf;MACF;IACF,UAAA;AACE,WAAKmE,QAAQ,KAAK9F,cAAcyH,KAAAA;IAClC;AACA,WAAOF,KAAKtC;EACd;;;;;;;EAQA,MAAc2D,MACZiB,OACA7B,OACA8B,OACAC,aACuC;AACvC,UAAM5G,IAAI,KAAKjB,EAAE2H,KAAAA;AACjB,UAAM5B,cAAc,KAAK5F,IAAG,IAAK,KAAKhC;AACtC,UAAMoH,QAAQ,GAAG,KAAK/G,UAAU,QAAIoB,+BAAAA,CAAAA;AACpC,UAAMyF,OAAO,MAAM,KAAK1H,KAAKqI,YAAY,OAAOC,OAAAA;AAC9C,YAAM6B,cAAc,IAAI,KAAK9H,EAAE,YAAA,CAAA,eAA4B,KAAKA,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG+H,YAAY9E,SAAS,CAAA,CAAA;AAClH,YAAMgF,QAAQ,MAAM9B,GAAGvF,MACrB,iBAAiBO,CAAAA,UAAW2G,KAAAA,QAAaE,WAAAA;oBAC7B,KAAK9H,EAAE,YAAA,CAAA,cAA2BT,KAAKiF,IAAI,GAAGjF,KAAKC,MAAMsG,KAAAA,CAAAA,CAAAA,2BACrE;WAAI+B;QAAa9B;OAAY;AAE/B,UAAIgC,MAAMhF,SAAS,GAAG;AACpB,cAAMiF,MAAMD,MAAM1G,IAAI,CAACoC,MAAMA,EAAEuD,OAAO;AACtC,cAAMiB,eAAeD,IAAI3G,IAAI,CAACG,GAAGzB,MAAM,KAAKD,GAAGC,IAAI,CAAA,CAAA,EAAIwB,KAAK,IAAA;AAC5D,cAAM0E,GAAGvF,MACP,UAAUO,CAAAA,QAAS,KAAKjB,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,KAAO,KAAKE,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA;mBACrF,KAAKE,EAAE,SAAA,CAAA,QAAkBiI,YAAAA,KAClC;UAAC1C;UAAO,KAAKpF,IAAG;aAAO6H;SAAI;MAE/B;AACA,aAAOD;IACT,CAAA;AACA,WAAO;MAAE1C;MAAME;IAAM;EACvB;;EAGQoB,KAAKgB,OAAepC,OAAqB;AAC/C,QAAIe,SAAS,KAAKrH,KAAKmI,IAAIO,KAAAA;AAC3B,QAAI,CAACrB,QAAQ;AACXA,eAAS,oBAAIrI,IAAAA;AACb,WAAKgB,KAAKmD,IAAIuF,OAAOrB,MAAAA;IACvB;AACAA,WAAO3B,IAAIY,KAAAA;AACX,QAAI,KAAKrG,WAAY;AACrB,UAAMgJ,aAAa3I,KAAKiF,IAAI,IAAIjF,KAAKC,MAAM,KAAKrB,UAAU,CAAA,CAAA;AAC1D,SAAKe,aAAa6F,YAAY,MAAA;AAC5B,UAAI,KAAK5F,QAAS;AAClB,YAAMgJ,QAAQ,KAAKC,UAAS,EACzB7H,MAAM,CAACd,QAAQ,KAAKnB,QAAQmB,GAAAA,CAAAA,EAC5BiG,QAAQ,MAAA;AACP,YAAI,KAAKvG,YAAYgJ,MAAO,MAAKhJ,UAAU5B;MAC7C,CAAA;AACF,WAAK4B,UAAUgJ;IACjB,GAAGD,UAAAA;AACH,SAAKhJ,WAAW+F,QAAK;EACvB;EAEQrB,QAAQ+D,OAAepC,OAAqB;AAClD,UAAMe,SAAS,KAAKrH,KAAKmI,IAAIO,KAAAA;AAC7BrB,YAAQzB,OAAOU,KAAAA;AACf,QAAIe,QAAQlB,SAAS,EAAG,MAAKnG,KAAK4F,OAAO8C,KAAAA;AACzC,QAAI,KAAK1I,KAAKmG,SAAS,KAAK,KAAKlG,YAAY;AAC3C2G,oBAAc,KAAK3G,UAAU;AAC7B,WAAKA,aAAa3B;IACpB;EACF;;EAGA,MAAc6K,YAA2B;AACvC,eAAW,CAACT,OAAOrB,MAAAA,KAAW,KAAKrH,MAAM;AACvC,UAAIqH,OAAOlB,SAAS,EAAG;AACvB,YAAMiD,OAAO;WAAI/B;;AACjB,YAAM2B,eAAeI,KAAKhH,IAAI,CAACG,GAAGzB,MAAM,KAAKD,GAAGC,IAAI,CAAA,CAAA,EAAIwB,KAAK,IAAA;AAC7D,YAAM,KAAK5D,KAAK+C,MACd,UAAU,KAAKV,EAAE2H,KAAAA,CAAAA,QAAc,KAAK3H,EAAE,YAAA,CAAA,MAAmB,KAAKF,GAAG,CAAA,CAAA,UAAY,KAAKE,EAAE,YAAA,CAAA,QAAqBiI,YAAAA,KACzG;QAAC,KAAK9H,IAAG;WAAOkI;OAAK;IAEzB;EACF;;;;;;EAOA,MAAcf,aAAaJ,QAAoBjB,KAAY,KAAKtI,MAAqB;AACnF,UAAMsD,IAAI,KAAKjB,EAAE,KAAKlC,YAAY;AAClC,UAAMqD,OAAO;MACX;MACA;MACA;MACA;MACA;MACA;MACA;MACA;;AAEF,UAAMC,UAAU;MAAC;MAAU;MAAO;MAAU;MAAU;MAAS;MAAc;;AAC7E,UAAMiC,SAAS,IAAIlC,KAAKE,IAAI,CAACC,MAAM,KAAKtB,EAAEsB,CAAAA,CAAAA,EAAIC,KAAK,IAAA,CAAA,aAAkBJ,KAAKE,IAAI,CAACG,GAAGzB,MAAM,KAAKD,GAAGC,IAAI,CAAA,CAAA,EAAIwB,KAAK,IAAA,CAAA;AAC7G,UAAMd,MAAM,KAAKhC,OACb,eAAewC,CAAAA,IAAKoC,MAAAA,iBAAuB,KAAKrD,EAAE,SAAA,CAAA,mBAA6B;SAC1EoB,QAAQC,IAAI,CAACC,MAAM,GAAG,KAAKtB,EAAEsB,CAAAA,CAAAA,eAAiB,KAAKtB,EAAEsB,CAAAA,CAAAA,EAAI;MAC5D,GAAG,KAAKtB,EAAE,YAAA,CAAA;MACV,GAAG,KAAKA,EAAE,YAAA,CAAA;MACVuB,KAAK,IAAA,CAAA,KACP,eAAeN,CAAAA,IAAKoC,MAAAA,4BAAkC;SACjDjC,QAAQC,IAAI,CAACC,MAAM,GAAG,KAAKtB,EAAEsB,CAAAA,CAAAA,aAAe,KAAKtB,EAAEsB,CAAAA,CAAAA,GAAK;MAC3D,GAAG,KAAKtB,EAAE,YAAA,CAAA;MACV,GAAG,KAAKA,EAAE,YAAA,CAAA;MACVuB,KAAK,IAAA,CAAA;AACX,UAAM0E,GAAGvF,MAAMD,KAAK;MAClByG,OAAOzF;MACPyF,OAAOxF;MACPwF,OAAOvF;MACPuF,OAAOK;MACPL,OAAOM,WAAWjK,SAAY,OAAOsE,KAAKC,UAAUoF,OAAOM,MAAM;MACjEN,OAAOvH,UAAUpC,SAAY,OAAOsE,KAAKC,UAAUoF,OAAOvH,KAAK;MAC/DuH,OAAOO,aAAa;MACpB,KAAKtH,IAAG;KACT;EACH;EAEQwF,MAAM2C,IAA2B;AACvC,WAAO,IAAIhE,QAAQ,CAACb,MAAM8E,WAAW9E,GAAG6E,EAAAA,CAAAA;EAC1C;;EAGA,MAAME,QAAuB;AAC3B,SAAK5J,UAAU;AACf,UAAM0F,QAAQsB,WAAW;MACvB,KAAK9G;MACL,KAAKC;SACF;WAAI,KAAKf;QAAcqD,IAAI,CAACC,MAAM,KAAKsD,gBAAgBtD,CAAAA,CAAAA;KAC3D;AAED,UAAMgD,QAAQsB,WAAW;SAAI,KAAK5G;KAAa;AAC/C,QAAI,KAAKE,WAAY2G,eAAc,KAAK3G,UAAU;AAClD,SAAKA,aAAa3B;AAClB,UAAM,KAAK4B;EACb;AACF;","names":["typeOrmExecutor","ds","dialect","test","String","options","type","escapeId","id","driver","escape","query","sql","params","transaction","fn","qr","createQueryRunner","connect","startTransaction","result","commitTransaction","err","rollbackTransaction","release","mikroOrmExecutor","em","platform","getPlatform","name","quoteIdentifier","getConnection","execute","transactional","txEm","getTransactionContext","RUNS_INSERT_CHUNK","RUNS_CLAIM_MAX","numberOption","value","fallback","min","undefined","Number","isFinite","DbTransport","exec","group","tasksTable","resultsTable","runsTable","runConsumers","Set","pollMs","leaseMs","batchSize","concurrency","onError","autoCreate","instanceId","isPg","handlers","Map","running","schemaReady","taskLoop","resultLoop","runningTasks","held","renewTimer","renewal","options","executor","prefix","Math","floor","err","console","error","randomUUID","dialect","ph","i","q","id","escapeId","now","Date","ensureSchema","createTables","catch","createIfMissing","sql","query","str","txt","tasks","results","dispatch","task","t","ignore","cols","replace","map","c","join","_","stepId","runId","seq","name","JSON","stringify","input","attempt","handle","fn","Error","set","loop","drainTasks","onResult","handler","drainResults","onHeartbeat","_handler","dispatchRuns","runs","opts","length","byRun","run","has","reason","unique","values","at","chunk","slice","r","__","insert","release","wake","flatMap","namespace","priority","onDispatchedRun","consumer","stopped","inflight","slotFreed","Promise","resolve","max","ns","consumeRuns","add","stopRunConsumer","delete","renew","setInterval","renewRunLeases","unref","settled","free","size","rows","claimRuns","token","done","then","finally","sleep","allSettled","clearInterval","limit","staleBefore","transaction","tx","claimed","run_id","globalThis","crypto","tokens","tick","processed","race","claim","hold","left","row","runTask","stillHolds","step_id","parse","result","runStepHandler","get","settleTask","insertResult","status","output","startedAt","started_at","table","where","whereParams","leaseClause","found","ids","placeholders","intervalMs","round","renewHeld","list","ms","setTimeout","close"]}
+{"version":3,"sources":["../src/index.ts","../src/db-transport.ts","../src/executors.ts"],"sourcesContent":["export * from './db-transport';\n","import { randomUUID } from 'node:crypto';\nimport {\n  type Heartbeat,\n  type RemoteTask,\n  type RunConsumerOptions,\n  type RunDispatch,\n  type RunQueueOptions,\n  type StepHandler,\n  type StepResult,\n  type Transport,\n  runStepHandler,\n} from '@dudousxd/nestjs-durable-core';\nimport type { SqlExecutor, SqlTx } from './executors';\n\nexport { mikroOrmExecutor, type SqlExecutor, type SqlTx, typeOrmExecutor } from './executors';\n\n/** Raw row shapes returned by `SELECT *` (declared fields, so they're not `| undefined` under noUncheckedIndexedAccess). */\ninterface TaskRow {\n  step_id: string;\n  run_id: string;\n  seq: string | number;\n  name: string;\n  input: string | null;\n  attempt: string | number;\n}\ninterface RunRow {\n  run_id: string;\n  wake: number | string;\n}\n\n/** A claimed run row: its run id and the token of this claim. */\ninterface ClaimedRun {\n  run: RunDispatch;\n  token: string;\n}\n\n/** Most rows one {@link DbTransport.dispatchRuns} insert writes. */\nconst RUNS_INSERT_CHUNK = 500;\n/** Tries for a statement the database rolled back as a deadlock (see `retryOnDeadlock`). */\nconst DEADLOCK_RETRIES = 5;\n\n/** Whether `err` is the database rolling a statement back to break a deadlock. */\nfunction isDeadlock(err: unknown): boolean {\n  const codes = [\n    (err as { code?: unknown }).code,\n    (err as { errno?: unknown }).errno,\n    (err as { driverError?: { code?: unknown; errno?: unknown } }).driverError?.code,\n    (err as { driverError?: { code?: unknown; errno?: unknown } }).driverError?.errno,\n  ];\n  return codes.some((c) => c === 'ER_LOCK_DEADLOCK' || c === 1213 || c === '40P01');\n}\n\n/** Most task rows one {@link DbTransport.dispatchMany} insert writes. */\nconst TASKS_INSERT_CHUNK = 200;\n\n/** Most run rows one consumer poll claims. */\nconst RUNS_CLAIM_MAX = 50;\n\n/**\n * Most results this instance hands the engine at once, and the most one poll claims. Results are\n * cheap to hand over: the engine writes one run's waiting results together, so the more of a wide\n * fan's results are in flight here, the fewer writes and barrier reads settle them.\n */\nconst RESULTS_IN_FLIGHT = 512;\nconst RESULTS_CLAIM_MAX = 256;\n\n/** A run-queue consumer started by {@link DbTransport.onDispatchedRun}. */\ninterface RunConsumer {\n  stopped: boolean;\n  /** Claim tokens of the rows whose runs are in flight. */\n  inflight: Set<string>;\n  slotFreed: (() => void) | undefined;\n  loop: Promise<void>;\n}\n\ninterface ResultRow {\n  step_id: string;\n  run_id: string;\n  seq: string | number;\n  status: string;\n  output: string | null;\n  error: string | null;\n  started_at: string | number | null;\n}\n\nexport interface DbTransportOptions {\n  /**\n   * How to run SQL — built from the app's **own** ORM/connection (no broker, no extra connection).\n   * Use `mikroOrmExecutor(em)` to ride the app's MikroORM, `typeOrmExecutor(dataSource)` for TypeORM,\n   * `drizzlePgExecutor(db)` (from `@dudousxd/nestjs-durable-store-drizzle/pg`) for Drizzle on\n   * Postgres, or implement `SqlExecutor` for anything else.\n   */\n  executor: SqlExecutor;\n  /** The worker group this instance serves. Required to register `handle()` consumers. */\n  group?: string;\n  /**\n   * Table-name prefix. Tables: `${prefix}_transport_tasks` / `${prefix}_transport_results`, and\n   * `${prefix}_transport_runs` for the run queue. Default `durable`.\n   */\n  prefix?: string;\n  /** Poll interval in ms when a queue is empty. Default 500. */\n  pollMs?: number;\n  /**\n   * How long a claimed row is owned before it's reclaimable (crash recovery), in ms. Default 30_000.\n   * Every claim this instance holds is renewed every `leaseMs / 3` while it is waiting or running, so\n   * a step may run longer than `leaseMs`; only a crashed (or event-loop-blocked) instance loses it.\n   */\n  leaseMs?: number;\n  /**\n   * Max rows claimed per poll. Default 10. The task loop claims only as many rows as it has free\n   * {@link concurrency} slots (capped by this). The results loop claims results in larger rounds of\n   * its own (a few hundred, or this if larger), since the engine settles them together.\n   */\n  batchSize?: number;\n  /**\n   * How many tasks this instance runs at once (worker side). Default 1. A row is claimed only when a\n   * slot is free to run it, so rows never wait claimed behind a slow task while a sibling sits idle.\n   */\n  concurrency?: number;\n  /**\n   * Where a transport failure is reported: a failing poll, a throwing result handler (the result is\n   * re-delivered after the lease), a lost claim. Default `console.error`.\n   */\n  onError?: (err: unknown) => void;\n  /** Create the tables on first use if missing. Default true. */\n  autoCreate?: boolean;\n  /** Identifies this instance in `claimed_by` (for debugging). Defaults to a random id. */\n  instanceId?: string;\n}\n\n/**\n * A numeric option: `fallback` unless `value` is a finite number of at least `min`. `Math.max(1, NaN)`\n * is `NaN`, so a clamp alone would let a `NaN` through (to `LIMIT NaN`, or a `NaN` timer).\n */\nfunction numberOption(value: number | undefined, fallback: number, min: number): number {\n  return value !== undefined && Number.isFinite(value) && value >= min ? value : fallback;\n}\n\n/**\n * A SQL-backed `Transport` — DBOS-style. Instead of a broker (Redis/SQS), remote steps are **rows**\n * in the same database the durable store already uses: `dispatch` inserts a task row, a worker\n * claims it with `SELECT … FOR UPDATE SKIP LOCKED` (so instances never double-claim), runs it, and\n * writes a result row the engine polls. Zero new infrastructure — the DB you already have IS the\n * queue.\n *\n * Trade-off vs a real broker: throughput is bounded by polling + row contention. Great for\n * workflow/pipeline scale (modest rate, long steps); not for high-fanout firehoses.\n *\n * Requires `FOR UPDATE SKIP LOCKED` — **MySQL 8+** or **Postgres 9.5+** (not SQLite). Run one\n * instance engine-side (`onResult`, dispatches) and one per worker process (`handle()` for its group).\n */\nexport class DbTransport implements Transport {\n  private readonly exec: SqlExecutor;\n  private readonly group?: string | undefined;\n  private readonly tasksTable: string;\n  private readonly resultsTable: string;\n  private readonly runsTable: string;\n  private readonly runConsumers = new Set<RunConsumer>();\n  private readonly pollMs: number;\n  private readonly leaseMs: number;\n  private readonly batchSize: number;\n  private readonly concurrency: number;\n  private readonly onError: (err: unknown) => void;\n  private readonly autoCreate: boolean;\n  private readonly instanceId: string;\n  private readonly isPg: boolean;\n\n  private readonly handlers = new Map<string, StepHandler>();\n  private running = true;\n  private schemaReady?: Promise<void> | undefined;\n  private taskLoop?: Promise<void>;\n  private resultLoop?: Promise<void>;\n  /** Tasks running on this instance (at most `concurrency`). */\n  private readonly runningTasks = new Set<Promise<void>>();\n  /** Claim rounds of results being handled on this instance — see {@link drainResults}. */\n  private readonly runningResults = new Set<Promise<void>>();\n  /** Results being handled across {@link runningResults} (at most {@link RESULTS_IN_FLIGHT}). */\n  private resultsInFlight = 0;\n  /** Claim tokens this instance holds, by table — every one is renewed on `renewTimer`. */\n  private readonly held = new Map<string, Set<string>>();\n  private renewTimer?: ReturnType<typeof setInterval> | undefined;\n  private renewal?: Promise<void> | undefined;\n\n  constructor(options: DbTransportOptions) {\n    this.exec = options.executor;\n    this.group = options.group;\n    const prefix = options.prefix ?? 'durable';\n    this.tasksTable = `${prefix}_transport_tasks`;\n    this.resultsTable = `${prefix}_transport_results`;\n    this.runsTable = `${prefix}_transport_runs`;\n    this.pollMs = numberOption(options.pollMs, 500, 0);\n    this.leaseMs = numberOption(options.leaseMs, 30_000, 1);\n    this.batchSize = Math.floor(numberOption(options.batchSize, 10, 1));\n    this.concurrency = Math.floor(numberOption(options.concurrency, 1, 1));\n    this.onError = options.onError ?? ((err) => console.error('[DbTransport]', err));\n    this.autoCreate = options.autoCreate ?? true;\n    // Random, not time-based: two instances booted in the same millisecond must not share an id.\n    this.instanceId = options.instanceId ?? `db-${randomUUID()}`;\n    this.isPg = this.exec.dialect === 'postgres';\n  }\n\n  // ── dialect helpers ──────────────────────────────────────────────────────────────────────────\n  /** Positional placeholder for param `i` (1-based): `$i` on Postgres, `?` elsewhere. */\n  private ph(i: number): string {\n    return this.isPg ? `$${i}` : '?';\n  }\n  private q(id: string): string {\n    return this.exec.escapeId(id);\n  }\n  private now(): number {\n    return Math.floor(Date.now());\n  }\n\n  // ── schema ───────────────────────────────────────────────────────────────────────────────────\n  private ensureSchema(): Promise<void> {\n    if (!this.schemaReady) {\n      // A failed attempt is not cached: the next call tries again instead of failing forever.\n      this.schemaReady = this.createTables().catch((err) => {\n        this.schemaReady = undefined;\n        throw err;\n      });\n    }\n    return this.schemaReady;\n  }\n\n  /**\n   * Run one `CREATE … IF NOT EXISTS`. Two instances booting on a fresh database race it, and Postgres\n   * can reject the loser with a unique violation on its catalog even with `IF NOT EXISTS`; the\n   * statement is simply re-run, by which point the table exists and it is a no-op.\n   */\n  private async createIfMissing(sql: string): Promise<void> {\n    try {\n      await this.exec.query(sql);\n    } catch {\n      await this.exec.query(sql);\n    }\n  }\n\n  private async createTables(): Promise<void> {\n    if (!this.autoCreate) return;\n    const str = 'varchar(191)';\n    const txt = this.isPg ? 'text' : 'longtext';\n    const tasks = this.q(this.tasksTable);\n    const results = this.q(this.resultsTable);\n    await this.createIfMissing(\n      `CREATE TABLE IF NOT EXISTS ${tasks} (\n        ${this.q('step_id')} ${str} PRIMARY KEY,\n        ${this.q('run_id')} ${str} NOT NULL,\n        ${this.q('seq')} integer NOT NULL,\n        ${this.q('name')} ${str} NOT NULL,\n        ${this.q('grp')} ${str} NOT NULL,\n        ${this.q('input')} ${txt},\n        ${this.q('attempt')} integer NOT NULL,\n        ${this.q('status')} varchar(32) NOT NULL,\n        ${this.q('claimed_by')} ${str},\n        ${this.q('claimed_at')} bigint,\n        ${this.q('created_at')} bigint NOT NULL\n      )`,\n    );\n    await this.createIfMissing(\n      `CREATE TABLE IF NOT EXISTS ${results} (\n        ${this.q('step_id')} ${str} PRIMARY KEY,\n        ${this.q('run_id')} ${str} NOT NULL,\n        ${this.q('seq')} integer NOT NULL,\n        ${this.q('status')} varchar(32) NOT NULL,\n        ${this.q('output')} ${txt},\n        ${this.q('error')} ${txt},\n        ${this.q('started_at')} bigint,\n        ${this.q('claimed_by')} ${str},\n        ${this.q('claimed_at')} bigint,\n        ${this.q('created_at')} bigint NOT NULL\n      )`,\n    );\n    await this.createIfMissing(\n      `CREATE TABLE IF NOT EXISTS ${this.q(this.runsTable)} (\n        ${this.q('run_id')} ${str} PRIMARY KEY,\n        ${this.q('ns')} ${str} NOT NULL,\n        ${this.q('priority')} integer NOT NULL,\n        ${this.q('wake')} integer NOT NULL,\n        ${this.q('claimed_by')} ${str},\n        ${this.q('claim_token')} ${str},\n        ${this.q('claimed_at')} bigint,\n        ${this.q('created_at')} bigint NOT NULL\n      )`,\n    );\n    await this.exec\n      .query(\n        `CREATE INDEX ${this.q(`${this.runsTable}_ns_idx`)} ON ${this.q(this.runsTable)} (${this.q('ns')}, ${this.q('priority')}, ${this.q('created_at')})`,\n      )\n      .catch(() => {});\n    // Best-effort index for the group poll (MySQL has no CREATE INDEX IF NOT EXISTS < 8.0.13).\n    await this.exec\n      .query(\n        `CREATE INDEX ${this.q(`${this.tasksTable}_grp_idx`)} ON ${tasks} (${this.q('grp')}, ${this.q('status')}, ${this.q('created_at')})`,\n      )\n      .catch(() => {});\n  }\n\n  // ── engine → worker ────────────────────────────────────────────────────────────────────────\n  async dispatch(task: RemoteTask): Promise<void> {\n    await this.dispatchMany([task]);\n  }\n\n  /** {@link dispatch} for many tasks: one multi-row insert per {@link TASKS_INSERT_CHUNK} tasks. */\n  async dispatchMany(tasks: RemoteTask[]): Promise<void> {\n    if (tasks.length === 0) return;\n    await this.ensureSchema();\n    const t = this.q(this.tasksTable);\n    const cols = [\n      'step_id',\n      'run_id',\n      'seq',\n      'name',\n      'grp',\n      'input',\n      'attempt',\n      'status',\n      'created_at',\n    ];\n    for (let at = 0; at < tasks.length; at += TASKS_INSERT_CHUNK) {\n      const chunk = tasks.slice(at, at + TASKS_INSERT_CHUNK);\n      const values = chunk\n        .map((_, r) => `(${cols.map((__, c) => this.ph(r * cols.length + c + 1)).join(', ')})`)\n        .join(', ');\n      const into = `${t} (${cols.map((c) => this.q(c)).join(', ')}) VALUES ${values}`;\n      // Idempotent: a redelivered dispatch for the same step_id is ignored (the row already exists).\n      const sql = this.isPg\n        ? `INSERT INTO ${into} ON CONFLICT (${this.q('step_id')}) DO NOTHING`\n        : `INSERT IGNORE INTO ${into}`;\n      const now = this.now();\n      await this.exec.query(\n        sql,\n        chunk.flatMap((task) => [\n          task.stepId,\n          task.runId,\n          task.seq,\n          task.name,\n          task.group,\n          JSON.stringify(task.input ?? null),\n          task.attempt,\n          'pending',\n          now,\n        ]),\n      );\n    }\n  }\n\n  // ── worker → engine ────────────────────────────────────────────────────────────────────────\n  handle(name: string, fn: StepHandler): void {\n    if (!this.group) throw new Error('DbTransport needs a `group` to register handlers');\n    this.handlers.set(name, fn);\n    if (!this.taskLoop) this.taskLoop = this.loop(() => this.drainTasks(this.group as string));\n  }\n\n  onResult(handler: (result: StepResult) => Promise<void>): void {\n    if (!this.resultLoop) this.resultLoop = this.loop(() => this.drainResults(handler));\n  }\n\n  onHeartbeat(_handler: (beat: Heartbeat) => Promise<void>): void {\n    // Not modelled; the lease/reclaim on `claimed_at` is the liveness mechanism.\n  }\n\n  // ── run queue (engine ↔ engine) ─────────────────────────────────────────────────────────────\n  /**\n   * Queue `pending` runs for whichever engine instance polls the run queue first: one row per run,\n   * keyed by run id, so a run already waiting is not queued twice. A run whose row an instance holds\n   * right now is released for another take, so a dispatch landing while the run's previous entry is\n   * being handled is not lost when that entry is deleted. Up to {@link RUNS_INSERT_CHUNK} rows per\n   * insert.\n   */\n  async dispatchRuns(runs: readonly RunDispatch[], opts?: RunQueueOptions): Promise<void> {\n    if (runs.length === 0) return;\n    await this.ensureSchema();\n    // One row per run (an upsert may not touch the same row twice in one statement); a wake among\n    // a run's dispatches makes its row a wake.\n    const byRun = new Map<string, RunDispatch>();\n    for (const run of runs) {\n      if (!byRun.has(run.runId) || run.reason === 'wake') byRun.set(run.runId, run);\n    }\n    // In run-id order: two dispatches touching overlapping rows lock them in the same order.\n    const unique = [...byRun.values()].sort((a, b) =>\n      a.runId < b.runId ? -1 : a.runId > b.runId ? 1 : 0,\n    );\n    const t = this.q(this.runsTable);\n    const cols = ['run_id', 'ns', 'priority', 'wake', 'created_at'];\n    const now = this.now();\n    for (let at = 0; at < unique.length; at += RUNS_INSERT_CHUNK) {\n      const chunk = unique.slice(at, at + RUNS_INSERT_CHUNK);\n      const values = chunk\n        .map((_, r) => `(${cols.map((__, c) => this.ph(r * cols.length + c + 1)).join(', ')})`)\n        .join(', ');\n      const insert = `INTO ${t} (${cols.map((c) => this.q(c)).join(', ')}) VALUES ${values}`;\n      const release = ['claimed_by', 'claim_token', 'claimed_at']\n        .map((c) => `${this.q(c)} = NULL`)\n        .join(', ');\n      const wake = this.q('wake');\n      const sql = this.isPg\n        ? `INSERT ${insert} ON CONFLICT (${this.q('run_id')}) DO UPDATE SET ${release}, ${wake} = GREATEST(${t}.${wake}, EXCLUDED.${wake})`\n        : `INSERT ${insert} ON DUPLICATE KEY UPDATE ${release}, ${wake} = GREATEST(${wake}, VALUES(${wake}))`;\n      await this.retryOnDeadlock(() =>\n        this.exec.query(\n          sql,\n          chunk.flatMap((run, r) => [\n            run.runId,\n            opts?.namespace ?? '',\n            run.priority ?? 0,\n            run.reason === 'wake' ? 1 : 0,\n            now + r,\n          ]),\n        ),\n      );\n    }\n  }\n\n  /**\n   * Poll the run queue, at most `opts.concurrency` runs in flight on this instance. Rows are claimed\n   * with `FOR UPDATE SKIP LOCKED` (instances never take the same run), highest priority then oldest\n   * first; a row is deleted once its handler settles, and its lease is renewed meanwhile, so a row is\n   * re-taken only after the instance holding it went down. The returned stop takes no more rows and\n   * resolves once the runs in flight settled.\n   */\n  onDispatchedRun(\n    handler: (run: RunDispatch) => Promise<void>,\n    opts: RunConsumerOptions,\n  ): () => Promise<void> {\n    const consumer: RunConsumer = {\n      stopped: false,\n      inflight: new Set(),\n      slotFreed: undefined,\n      loop: Promise.resolve(),\n    };\n    const concurrency = Math.max(1, Math.floor(opts.concurrency));\n    const ns = opts.namespace ?? '';\n    consumer.loop = this.consumeRuns(consumer, handler, concurrency, ns).catch((err) => {\n      this.onError(err);\n    });\n    this.runConsumers.add(consumer);\n    return () => this.stopRunConsumer(consumer);\n  }\n\n  private async stopRunConsumer(consumer: RunConsumer): Promise<void> {\n    consumer.stopped = true;\n    consumer.slotFreed?.();\n    await consumer.loop;\n    this.runConsumers.delete(consumer);\n  }\n\n  private async consumeRuns(\n    consumer: RunConsumer,\n    handler: (run: RunDispatch) => Promise<void>,\n    concurrency: number,\n    ns: string,\n  ): Promise<void> {\n    const renew = setInterval(\n      () => void this.renewRunLeases(consumer).catch(() => undefined),\n      Math.max(1_000, Math.floor(this.leaseMs / 3)),\n    );\n    renew.unref?.();\n    const settled = new Set<Promise<unknown>>();\n    try {\n      while (this.running && !consumer.stopped) {\n        const free = concurrency - consumer.inflight.size;\n        if (free <= 0) {\n          await new Promise<void>((resolve) => {\n            consumer.slotFreed = resolve;\n          });\n          consumer.slotFreed = undefined;\n          continue;\n        }\n        let rows: ClaimedRun[] = [];\n        try {\n          await this.ensureSchema();\n          rows = await this.retryOnDeadlock(() =>\n            this.claimRuns(ns, Math.min(free, RUNS_CLAIM_MAX)),\n          );\n        } catch (err) {\n          if (this.running && !consumer.stopped) this.onError(err);\n        }\n        for (const { run, token } of rows) {\n          consumer.inflight.add(token);\n          const done = handler(run)\n            .catch(() => undefined)\n            .then(() =>\n              this.retryOnDeadlock(() =>\n                this.exec.query(\n                  `DELETE FROM ${this.q(this.runsTable)} WHERE ${this.q('claim_token')} = ${this.ph(1)}`,\n                  [token],\n                ),\n              ).catch(() => undefined),\n            )\n            .finally(() => {\n              consumer.inflight.delete(token);\n              settled.delete(done);\n              consumer.slotFreed?.();\n            });\n          settled.add(done);\n        }\n        if (rows.length === 0) await this.sleep(this.pollMs);\n      }\n      await Promise.allSettled([...settled]);\n    } finally {\n      clearInterval(renew);\n    }\n  }\n\n  /**\n   * Run `statement`, again on a deadlock: queueing a run (an upsert), taking one (`SKIP LOCKED`)\n   * and deleting a handled one touch the same rows from different instances, and the database then\n   * rolls one of them back rather than wait (InnoDB reports `ER_LOCK_DEADLOCK`, Postgres `40P01`).\n   */\n  private async retryOnDeadlock<T>(statement: () => Promise<T>): Promise<T> {\n    for (let attempt = 1; ; attempt += 1) {\n      try {\n        return await statement();\n      } catch (err) {\n        if (attempt >= DEADLOCK_RETRIES || !isDeadlock(err)) throw err;\n        await this.sleep(10 * attempt + Math.floor(Math.random() * 10));\n      }\n    }\n  }\n\n  private async claimRuns(ns: string, limit: number): Promise<ClaimedRun[]> {\n    const t = this.q(this.runsTable);\n    const staleBefore = this.now() - this.leaseMs;\n    return this.exec.transaction(async (tx) => {\n      const rows = await tx.query<RunRow>(\n        `SELECT ${this.q('run_id')}, ${this.q('wake')} FROM ${t}\n         WHERE ${this.q('ns')} = ${this.ph(1)}\n           AND (${this.q('claimed_at')} IS NULL OR ${this.q('claimed_at')} < ${this.ph(2)})\n         ORDER BY ${this.q('priority')} DESC, ${this.q('created_at')} ASC\n         LIMIT ${Math.floor(limit)} FOR UPDATE SKIP LOCKED`,\n        [ns, staleBefore],\n      );\n      const claimed = rows.map((r) => ({\n        run: {\n          runId: r.run_id,\n          reason: Number(r.wake) === 1 ? ('wake' as const) : ('start' as const),\n        },\n        token: globalThis.crypto.randomUUID(),\n      }));\n      const now = this.now();\n      for (const {\n        run: { runId },\n        token,\n      } of claimed) {\n        await tx.query(\n          `UPDATE ${t} SET ${this.q('claimed_by')} = ${this.ph(1)}, ${this.q('claim_token')} = ${this.ph(2)}, ${this.q('claimed_at')} = ${this.ph(3)}\n           WHERE ${this.q('run_id')} = ${this.ph(4)}`,\n          [this.instanceId, token, now, runId],\n        );\n      }\n      return claimed;\n    });\n  }\n\n  /** Keep the rows of the runs in flight leased, so a long turn is not re-taken by another instance. */\n  private async renewRunLeases(consumer: RunConsumer): Promise<void> {\n    const tokens = [...consumer.inflight];\n    if (tokens.length === 0) return;\n    await this.exec.query(\n      `UPDATE ${this.q(this.runsTable)} SET ${this.q('claimed_at')} = ${this.ph(1)}\n       WHERE ${this.q('claim_token')} IN (${tokens.map((_, i) => this.ph(i + 2)).join(', ')})`,\n      [this.now(), ...tokens],\n    );\n  }\n\n  // ── polling ──────────────────────────────────────────────────────────────────────────────────\n  /** Run `tick` repeatedly; sleep `pollMs` when it reports an empty queue. Stops on `close()`. */\n  private async loop(tick: () => Promise<number>): Promise<void> {\n    while (this.running) {\n      let processed = 0;\n      try {\n        await this.ensureSchema();\n        processed = await tick();\n      } catch (err) {\n        if (this.running) this.onError(err);\n      }\n      if (processed === 0 && this.running) await this.sleep(this.pollMs);\n    }\n  }\n\n  /**\n   * One task-loop round: claim as many rows as there are free slots (never more — a claimed row that\n   * isn't running is one an idle sibling can't run), and start each. With every slot busy, wait for\n   * one to free instead of polling.\n   */\n  private async drainTasks(group: string): Promise<number> {\n    const free = this.concurrency - this.runningTasks.size;\n    if (free <= 0) {\n      await Promise.race(this.runningTasks);\n      return 1;\n    }\n    const { rows, token } = await this.claim<TaskRow>(\n      this.tasksTable,\n      Math.min(free, this.batchSize),\n      `${this.q('grp')} = ${this.ph(1)}`,\n      [group],\n    );\n    if (rows.length === 0) return 0;\n    this.hold(this.tasksTable, token);\n    let left = rows.length;\n    for (const row of rows) {\n      const run = this.runTask(row, group, token).finally(() => {\n        this.runningTasks.delete(run);\n        left -= 1;\n        if (left === 0) this.release(this.tasksTable, token);\n      });\n      this.runningTasks.add(run);\n    }\n    return rows.length;\n  }\n\n  /**\n   * Run one claimed task and settle it — only while this instance still holds the claim: the claim is\n   * re-checked before running, and the task row is deleted and its result written in ONE transaction,\n   * conditional on the claim token, so an instance whose claim was taken over neither deletes the new\n   * holder's row nor publishes a second result.\n   */\n  private async runTask(row: TaskRow, group: string, token: string): Promise<void> {\n    try {\n      if (!(await this.stillHolds(row.step_id, token))) {\n        this.onError(\n          new Error(\n            `[DbTransport] lost the claim on task ${row.step_id} before running it — another instance took it over; not running it here`,\n          ),\n        );\n        return;\n      }\n      const task: RemoteTask = {\n        runId: row.run_id,\n        seq: Number(row.seq),\n        stepId: row.step_id,\n        name: row.name,\n        group,\n        input: row.input == null ? undefined : JSON.parse(row.input),\n        attempt: Number(row.attempt),\n      };\n      const result = await runStepHandler(task, this.handlers.get(task.name));\n      if (!(await this.settleTask(task.stepId, token, result))) {\n        this.onError(\n          new Error(\n            `[DbTransport] lost the claim on task ${task.stepId} while running it (this instance went silent past leaseMs) — another instance took it over and may run it too; this run's result was dropped. Raise leaseMs if steps block the event loop`,\n          ),\n        );\n      }\n    } catch (err) {\n      // A database error settling the row (or a malformed row): it stays claimed, stops being\n      // renewed, and is reclaimed after the lease — at-least-once, like a crash.\n      this.onError(err);\n    }\n  }\n\n  /** Whether the claim on `stepId` is still `token`'s (re-stamping it if so). */\n  private async stillHolds(stepId: string, token: string): Promise<boolean> {\n    const t = this.q(this.tasksTable);\n    const rows = await this.exec.transaction(async (tx) => {\n      const held = await tx.query<{ step_id: string }>(\n        `SELECT ${this.q('step_id')} FROM ${t} WHERE ${this.q('step_id')} = ${this.ph(1)} AND ${this.q('claimed_by')} = ${this.ph(2)} FOR UPDATE`,\n        [stepId, token],\n      );\n      if (held.length > 0) {\n        await tx.query(\n          `UPDATE ${t} SET ${this.q('claimed_at')} = ${this.ph(1)} WHERE ${this.q('step_id')} = ${this.ph(2)} AND ${this.q('claimed_by')} = ${this.ph(3)}`,\n          [this.now(), stepId, token],\n        );\n      }\n      return held;\n    });\n    return rows.length > 0;\n  }\n\n  /** Delete the task row and publish its result in ONE transaction, only while `token` holds it. */\n  private async settleTask(stepId: string, token: string, result: StepResult): Promise<boolean> {\n    const t = this.q(this.tasksTable);\n    return this.exec.transaction(async (tx) => {\n      const held = await tx.query<{ step_id: string }>(\n        `SELECT ${this.q('step_id')} FROM ${t} WHERE ${this.q('step_id')} = ${this.ph(1)} AND ${this.q('claimed_by')} = ${this.ph(2)} FOR UPDATE`,\n        [stepId, token],\n      );\n      if (held.length === 0) return false;\n      await tx.query(\n        `DELETE FROM ${t} WHERE ${this.q('step_id')} = ${this.ph(1)} AND ${this.q('claimed_by')} = ${this.ph(2)}`,\n        [stepId, token],\n      );\n      await this.insertResult(result, tx);\n      return true;\n    });\n  }\n\n  /**\n   * Claim a batch of results and hand them all to the engine at once, then delete the ones whose\n   * handler resolved — only after it did (at-least-once), and only while this round still holds the\n   * claim (a newer result for the same step that replaced the row resets the claim, so it is\n   * delivered next instead of deleted). The next round is claimed while this one runs, up to\n   * {@link RESULTS_IN_FLIGHT} results; the round's claim is renewed until it is done. A throwing\n   * handler is reported and its row left for re-delivery after the lease.\n   */\n  private async drainResults(handler: (result: StepResult) => Promise<void>): Promise<number> {\n    const free = RESULTS_IN_FLIGHT - this.resultsInFlight;\n    if (free <= 0) {\n      await Promise.race(this.runningResults);\n      return 1;\n    }\n    const { rows, token } = await this.claim<ResultRow>(\n      this.resultsTable,\n      Math.min(free, Math.max(this.batchSize, RESULTS_CLAIM_MAX)),\n      '1 = 1',\n      [],\n    );\n    if (rows.length === 0) return 0;\n    this.hold(this.resultsTable, token);\n    this.resultsInFlight += rows.length;\n    const round = this.handleResults(rows, token, handler).finally(() => {\n      this.resultsInFlight -= rows.length;\n      this.runningResults.delete(round);\n      this.release(this.resultsTable, token);\n    });\n    this.runningResults.add(round);\n    return rows.length;\n  }\n\n  /** Hand one claimed round of results to the engine, then delete the delivered ones in one statement. */\n  private async handleResults(\n    rows: ResultRow[],\n    token: string,\n    handler: (result: StepResult) => Promise<void>,\n  ): Promise<void> {\n    const delivered: string[] = [];\n    await Promise.all(\n      rows.map(async (row) => {\n        try {\n          await handler({\n            runId: row.run_id,\n            seq: Number(row.seq),\n            stepId: row.step_id,\n            status: row.status as StepResult['status'],\n            output: row.output == null ? undefined : JSON.parse(row.output),\n            error: row.error == null ? undefined : JSON.parse(row.error),\n            startedAt: row.started_at == null ? undefined : Number(row.started_at),\n          });\n          delivered.push(row.step_id);\n        } catch (err) {\n          this.onError(err);\n        }\n      }),\n    );\n    if (delivered.length === 0) return;\n    try {\n      const ids = delivered.map((_, i) => this.ph(i + 2)).join(', ');\n      await this.exec.query(\n        `DELETE FROM ${this.q(this.resultsTable)} WHERE ${this.q('claimed_by')} = ${this.ph(1)} AND ${this.q('step_id')} IN (${ids})`,\n        [token, ...delivered],\n      );\n    } catch (err) {\n      // The rows stay and are re-delivered after the lease; the engine drops a settled step's copy.\n      this.onError(err);\n    }\n  }\n\n  /**\n   * Atomically claim up to `limit` un-leased rows matching `where` and stamp them with a claim token\n   * unique to this round (`<instanceId>:<uuid>`). `SELECT … FOR UPDATE SKIP LOCKED` inside the txn\n   * means concurrent instances skip each other's locked rows instead of blocking, so no row is\n   * claimed twice; the token is what every later delete/settle is conditional on.\n   */\n  private async claim<T extends { step_id: string }>(\n    table: string,\n    limit: number,\n    where: string,\n    whereParams: unknown[],\n  ): Promise<{ rows: T[]; token: string }> {\n    const t = this.q(table);\n    const staleBefore = this.now() - this.leaseMs;\n    const token = `${this.instanceId}:${randomUUID()}`;\n    const rows = await this.exec.transaction(async (tx) => {\n      const leaseClause = `(${this.q('claimed_at')} IS NULL OR ${this.q('claimed_at')} < ${this.ph(whereParams.length + 1)})`;\n      const found = await tx.query<T>(\n        `SELECT * FROM ${t} WHERE ${where} AND ${leaseClause}\n         ORDER BY ${this.q('created_at')} ASC LIMIT ${Math.max(1, Math.floor(limit))} FOR UPDATE SKIP LOCKED`,\n        [...whereParams, staleBefore],\n      );\n      if (found.length > 0) {\n        const ids = found.map((r) => r.step_id);\n        const placeholders = ids.map((_, i) => this.ph(i + 3)).join(', ');\n        await tx.query(\n          `UPDATE ${t} SET ${this.q('claimed_by')} = ${this.ph(1)}, ${this.q('claimed_at')} = ${this.ph(2)}\n           WHERE ${this.q('step_id')} IN (${placeholders})`,\n          [token, this.now(), ...ids],\n        );\n      }\n      return found;\n    });\n    return { rows, token };\n  }\n\n  // ── claim renewal: every claim held, not only the row being run ─────────────────────────────\n  private hold(table: string, token: string): void {\n    let tokens = this.held.get(table);\n    if (!tokens) {\n      tokens = new Set();\n      this.held.set(table, tokens);\n    }\n    tokens.add(token);\n    if (this.renewTimer) return;\n    const intervalMs = Math.max(10, Math.floor(this.leaseMs / 3));\n    this.renewTimer = setInterval(() => {\n      if (this.renewal) return; // a slow database never stacks renewal rounds\n      const round = this.renewHeld()\n        .catch((err) => this.onError(err))\n        .finally(() => {\n          if (this.renewal === round) this.renewal = undefined;\n        });\n      this.renewal = round;\n    }, intervalMs);\n    this.renewTimer.unref?.();\n  }\n\n  private release(table: string, token: string): void {\n    const tokens = this.held.get(table);\n    tokens?.delete(token);\n    if (tokens?.size === 0) this.held.delete(table);\n    if (this.held.size === 0 && this.renewTimer) {\n      clearInterval(this.renewTimer);\n      this.renewTimer = undefined;\n    }\n  }\n\n  /** Re-stamp `claimed_at` on every row still claimed under a token this instance holds. */\n  private async renewHeld(): Promise<void> {\n    for (const [table, tokens] of this.held) {\n      if (tokens.size === 0) continue;\n      const list = [...tokens];\n      const placeholders = list.map((_, i) => this.ph(i + 2)).join(', ');\n      await this.exec.query(\n        `UPDATE ${this.q(table)} SET ${this.q('claimed_at')} = ${this.ph(1)} WHERE ${this.q('claimed_by')} IN (${placeholders})`,\n        [this.now(), ...list],\n      );\n    }\n  }\n\n  /**\n   * Write a result row. A result already waiting for the same step (an earlier attempt's, not yet\n   * deleted by the engine) is REPLACED and its claim reset, never kept: `step_id` is stable across\n   * attempts, so keeping the old row would silently drop a retry's result.\n   */\n  private async insertResult(result: StepResult, tx: SqlTx = this.exec): Promise<void> {\n    const t = this.q(this.resultsTable);\n    const cols = [\n      'step_id',\n      'run_id',\n      'seq',\n      'status',\n      'output',\n      'error',\n      'started_at',\n      'created_at',\n    ];\n    const replace = ['run_id', 'seq', 'status', 'output', 'error', 'started_at', 'created_at'];\n    const values = `(${cols.map((c) => this.q(c)).join(', ')}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(', ')})`;\n    const sql = this.isPg\n      ? `INSERT INTO ${t} ${values} ON CONFLICT (${this.q('step_id')}) DO UPDATE SET ${[\n          ...replace.map((c) => `${this.q(c)} = EXCLUDED.${this.q(c)}`),\n          `${this.q('claimed_by')} = NULL`,\n          `${this.q('claimed_at')} = NULL`,\n        ].join(', ')}`\n      : `INSERT INTO ${t} ${values} ON DUPLICATE KEY UPDATE ${[\n          ...replace.map((c) => `${this.q(c)} = VALUES(${this.q(c)})`),\n          `${this.q('claimed_by')} = NULL`,\n          `${this.q('claimed_at')} = NULL`,\n        ].join(', ')}`;\n    await tx.query(sql, [\n      result.stepId,\n      result.runId,\n      result.seq,\n      result.status,\n      result.output === undefined ? null : JSON.stringify(result.output),\n      result.error === undefined ? null : JSON.stringify(result.error),\n      result.startedAt ?? null,\n      this.now(),\n    ]);\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise((r) => setTimeout(r, ms));\n  }\n\n  /** Stop the pollers and wait for the current ticks to settle. Does not close the shared DataSource. */\n  async close(): Promise<void> {\n    this.running = false;\n    await Promise.allSettled([\n      this.taskLoop,\n      this.resultLoop,\n      ...[...this.runConsumers].map((c) => this.stopRunConsumer(c)),\n    ]);\n    // Let running tasks and results settle (their claims keep being renewed until they do).\n    await Promise.allSettled([...this.runningTasks, ...this.runningResults]);\n    if (this.renewTimer) clearInterval(this.renewTimer);\n    this.renewTimer = undefined;\n    await this.renewal;\n  }\n}\n","/**\n * The tiny SQL surface `DbTransport` needs, so it rides **whatever ORM/connection the app already\n * has** instead of forcing a specific one. Implement it for your ORM (adapters for TypeORM and\n * MikroORM ship below) and hand it to `new DbTransport({ executor })`. Mirrors how the durable\n * *store* is ORM-pluggable (store-typeorm / store-mikro-orm / …).\n */\nexport interface SqlExecutor {\n  /** Drives placeholder style (`$n` vs `?`) and a couple of DDL type choices. */\n  readonly dialect: 'mysql' | 'postgres';\n  /** Quote/escape an identifier (table/column name) for this dialect. */\n  escapeId(id: string): string;\n  /** Run a statement outside a transaction. */\n  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;\n  /** Run `fn` inside a transaction — the claim uses `FOR UPDATE SKIP LOCKED` within it. */\n  transaction<T>(fn: (tx: SqlTx) => Promise<T>): Promise<T>;\n}\n\nexport interface SqlTx {\n  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;\n}\n\n// ── TypeORM ──────────────────────────────────────────────────────────────────────────────────────\n\n/** Structural slice of a TypeORM `DataSource` — avoids a hard dependency on typeorm. */\ninterface TypeOrmDataSourceLike {\n  options: { type: string };\n  driver: { escape(id: string): string };\n  query(sql: string, params?: unknown[]): Promise<unknown>;\n  createQueryRunner(): {\n    connect(): Promise<void>;\n    startTransaction(): Promise<void>;\n    commitTransaction(): Promise<void>;\n    rollbackTransaction(): Promise<void>;\n    release(): Promise<void>;\n    query(sql: string, params?: unknown[]): Promise<unknown>;\n  };\n}\n\n/** Build an executor from a TypeORM `DataSource` (e.g. the one the durable store already uses). */\nexport function typeOrmExecutor(ds: TypeOrmDataSourceLike): SqlExecutor {\n  return {\n    dialect: /postgres/.test(String(ds.options.type)) ? 'postgres' : 'mysql',\n    escapeId: (id) => ds.driver.escape(id),\n    query: <T>(sql: string, params?: unknown[]) => ds.query(sql, params) as Promise<T[]>,\n    transaction: async <T>(fn: (tx: SqlTx) => Promise<T>) => {\n      const qr = ds.createQueryRunner();\n      await qr.connect();\n      await qr.startTransaction();\n      try {\n        const result = await fn({\n          query: <U>(sql: string, params?: unknown[]) => qr.query(sql, params) as Promise<U[]>,\n        });\n        await qr.commitTransaction();\n        return result;\n      } catch (err) {\n        await qr.rollbackTransaction();\n        throw err;\n      } finally {\n        await qr.release();\n      }\n    },\n  };\n}\n\n// ── MikroORM ─────────────────────────────────────────────────────────────────────────────────────\n\n/** Structural slice of a MikroORM `EntityManager` — avoids a hard dependency on @mikro-orm/core. */\ninterface MikroOrmEmLike {\n  getPlatform(): { constructor: { name: string }; quoteIdentifier(id: string): string };\n  getConnection(): {\n    execute(sql: string, params?: unknown[], method?: 'all', ctx?: unknown): Promise<unknown>;\n  };\n  getTransactionContext?(): unknown;\n  transactional<T>(cb: (em: MikroOrmEmLike) => Promise<T>): Promise<T>;\n}\n\n/**\n * Build an executor from a MikroORM `EntityManager` — i.e. **the app's own configured ORM**. Runs\n * raw SQL through `em.getConnection().execute(...)` and wraps the claim in `em.transactional(...)`,\n * threading the transaction context so `FOR UPDATE SKIP LOCKED` locks within the tx.\n */\nexport function mikroOrmExecutor(em: MikroOrmEmLike): SqlExecutor {\n  const platform = em.getPlatform();\n  return {\n    dialect: /postgre/i.test(platform.constructor.name) ? 'postgres' : 'mysql',\n    escapeId: (id) => platform.quoteIdentifier(id),\n    query: <T>(sql: string, params?: unknown[]) =>\n      em.getConnection().execute(sql, params ?? [], 'all') as Promise<T[]>,\n    transaction: <T>(fn: (tx: SqlTx) => Promise<T>) =>\n      em.transactional((txEm) =>\n        fn({\n          query: <U>(sql: string, params?: unknown[]) =>\n            txEm\n              .getConnection()\n              .execute(sql, params ?? [], 'all', txEm.getTransactionContext?.()) as Promise<U[]>,\n        }),\n      ),\n  };\n}\n"],"mappings":"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","names":["typeOrmExecutor","ds","dialect","test","String","options","type","escapeId","id","driver","escape","query","sql","params","transaction","fn","qr","createQueryRunner","connect","startTransaction","result","commitTransaction","err","rollbackTransaction","release","mikroOrmExecutor","em","platform","getPlatform","name","quoteIdentifier","getConnection","execute","transactional","txEm","getTransactionContext","RUNS_INSERT_CHUNK","DEADLOCK_RETRIES","isDeadlock","err","codes","code","errno","driverError","some","c","TASKS_INSERT_CHUNK","RUNS_CLAIM_MAX","RESULTS_IN_FLIGHT","RESULTS_CLAIM_MAX","numberOption","value","fallback","min","undefined","Number","isFinite","DbTransport","exec","group","tasksTable","resultsTable","runsTable","runConsumers","Set","pollMs","leaseMs","batchSize","concurrency","onError","autoCreate","instanceId","isPg","handlers","Map","running","schemaReady","taskLoop","resultLoop","runningTasks","runningResults","resultsInFlight","held","renewTimer","renewal","options","executor","prefix","Math","floor","console","error","randomUUID","dialect","ph","i","q","id","escapeId","now","Date","ensureSchema","createTables","catch","createIfMissing","sql","query","str","txt","tasks","results","dispatch","task","dispatchMany","length","t","cols","at","chunk","slice","values","map","_","r","__","join","into","flatMap","stepId","runId","seq","name","JSON","stringify","input","attempt","handle","fn","Error","set","loop","drainTasks","onResult","handler","drainResults","onHeartbeat","_handler","dispatchRuns","runs","opts","byRun","run","has","reason","unique","sort","a","b","insert","release","wake","retryOnDeadlock","namespace","priority","onDispatchedRun","consumer","stopped","inflight","slotFreed","Promise","resolve","max","ns","consumeRuns","add","stopRunConsumer","delete","renew","setInterval","renewRunLeases","unref","settled","free","size","rows","claimRuns","token","done","then","finally","sleep","allSettled","clearInterval","statement","random","limit","staleBefore","transaction","tx","claimed","run_id","globalThis","crypto","tokens","tick","processed","race","claim","hold","left","row","runTask","stillHolds","step_id","parse","result","runStepHandler","get","settleTask","insertResult","round","handleResults","delivered","all","status","output","startedAt","started_at","push","ids","table","where","whereParams","leaseClause","found","placeholders","intervalMs","renewHeld","list","replace","ms","setTimeout","close"]}

package/dist/index.d.cts

@@ -85,7 +85,8 @@ interface DbTransportOptions {
     leaseMs?: number;
     /**
      * Max rows claimed per poll. Default 10. The task loop claims only as many rows as it has free
-     * {@link concurrency} slots (capped by this); the results loop claims up to this many.
+     * {@link concurrency} slots (capped by this). The results loop claims results in larger rounds of
+     * its own (a few hundred, or this if larger), since the engine settles them together.
      */
     batchSize?: number;
     /**
@@ -138,6 +139,10 @@ declare class DbTransport implements Transport {
     private resultLoop?;
     /** Tasks running on this instance (at most `concurrency`). */
     private readonly runningTasks;
+    /** Claim rounds of results being handled on this instance — see {@link drainResults}. */
+    private readonly runningResults;
+    /** Results being handled across {@link runningResults} (at most {@link RESULTS_IN_FLIGHT}). */
+    private resultsInFlight;
     /** Claim tokens this instance holds, by table — every one is renewed on `renewTimer`. */
     private readonly held;
     private renewTimer?;
@@ -156,6 +161,8 @@ declare class DbTransport implements Transport {
     private createIfMissing;
     private createTables;
     dispatch(task: RemoteTask): Promise<void>;
+    /** {@link dispatch} for many tasks: one multi-row insert per {@link TASKS_INSERT_CHUNK} tasks. */
+    dispatchMany(tasks: RemoteTask[]): Promise<void>;
     handle(name: string, fn: StepHandler): void;
     onResult(handler: (result: StepResult) => Promise<void>): void;
     onHeartbeat(_handler: (beat: Heartbeat) => Promise<void>): void;
@@ -177,6 +184,12 @@ declare class DbTransport implements Transport {
     onDispatchedRun(handler: (run: RunDispatch) => Promise<void>, opts: RunConsumerOptions): () => Promise<void>;
     private stopRunConsumer;
     private consumeRuns;
+    /**
+     * Run `statement`, again on a deadlock: queueing a run (an upsert), taking one (`SKIP LOCKED`)
+     * and deleting a handled one touch the same rows from different instances, and the database then
+     * rolls one of them back rather than wait (InnoDB reports `ER_LOCK_DEADLOCK`, Postgres `40P01`).
+     */
+    private retryOnDeadlock;
     private claimRuns;
     /** Keep the rows of the runs in flight leased, so a long turn is not re-taken by another instance. */
     private renewRunLeases;
@@ -200,13 +213,16 @@ declare class DbTransport implements Transport {
     /** Delete the task row and publish its result in ONE transaction, only while `token` holds it. */
     private settleTask;
     /**
-     * Claim a batch of results, deliver each to the engine, and delete it — only after its handler ran
-     * (at-least-once), and only while this round still holds the claim (a newer result for the same
-     * step that replaced the row resets the claim, so it is delivered next instead of deleted). The
-     * batch's claim is renewed until it is done. A throwing handler is reported and its row left for
-     * re-delivery after the lease; the rest of the batch continues.
+     * Claim a batch of results and hand them all to the engine at once, then delete the ones whose
+     * handler resolved — only after it did (at-least-once), and only while this round still holds the
+     * claim (a newer result for the same step that replaced the row resets the claim, so it is
+     * delivered next instead of deleted). The next round is claimed while this one runs, up to
+     * {@link RESULTS_IN_FLIGHT} results; the round's claim is renewed until it is done. A throwing
+     * handler is reported and its row left for re-delivery after the lease.
      */
     private drainResults;
+    /** Hand one claimed round of results to the engine, then delete the delivered ones in one statement. */
+    private handleResults;
     /**
      * Atomically claim up to `limit` un-leased rows matching `where` and stamp them with a claim token
      * unique to this round (`<instanceId>:<uuid>`). `SELECT … FOR UPDATE SKIP LOCKED` inside the txn