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

package/dist/index.js

@@ -2,6 +2,7 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/db-transport.ts
+import { randomUUID } from "node:crypto";
 import { runStepHandler } from "@dudousxd/nestjs-durable-core";
 
 // src/executors.ts
@@ -44,6 +45,12 @@ function mikroOrmExecutor(em) {
 __name(mikroOrmExecutor, "mikroOrmExecutor");
 
 // src/db-transport.ts
+var RUNS_INSERT_CHUNK = 500;
+var RUNS_CLAIM_MAX = 50;
+function numberOption(value, fallback, min) {
+  return value !== void 0 && Number.isFinite(value) && value >= min ? value : fallback;
+}
+__name(numberOption, "numberOption");
 var DbTransport = class {
   static {
     __name(this, "DbTransport");
@@ -52,9 +59,13 @@ var DbTransport = class {
   group;
   tasksTable;
   resultsTable;
+  runsTable;
+  runConsumers = /* @__PURE__ */ new Set();
   pollMs;
   leaseMs;
   batchSize;
+  concurrency;
+  onError;
   autoCreate;
   instanceId;
   isPg;
@@ -63,17 +74,26 @@ var DbTransport = class {
   schemaReady;
   taskLoop;
   resultLoop;
+  /** Tasks running on this instance (at most `concurrency`). */
+  runningTasks = /* @__PURE__ */ new Set();
+  /** Claim tokens this instance holds, by table — every one is renewed on `renewTimer`. */
+  held = /* @__PURE__ */ new Map();
+  renewTimer;
+  renewal;
   constructor(options) {
     this.exec = options.executor;
     this.group = options.group;
     const prefix = options.prefix ?? "durable";
     this.tasksTable = `${prefix}_transport_tasks`;
     this.resultsTable = `${prefix}_transport_results`;
-    this.pollMs = options.pollMs ?? 500;
-    this.leaseMs = options.leaseMs ?? 3e4;
-    this.batchSize = options.batchSize ?? 10;
+    this.runsTable = `${prefix}_transport_runs`;
+    this.pollMs = numberOption(options.pollMs, 500, 0);
+    this.leaseMs = numberOption(options.leaseMs, 3e4, 1);
+    this.batchSize = Math.floor(numberOption(options.batchSize, 10, 1));
+    this.concurrency = Math.floor(numberOption(options.concurrency, 1, 1));
+    this.onError = options.onError ?? ((err) => console.error("[DbTransport]", err));
     this.autoCreate = options.autoCreate ?? true;
-    this.instanceId = options.instanceId ?? `db-${Math.floor(Date.now()).toString(36)}`;
+    this.instanceId = options.instanceId ?? `db-${randomUUID()}`;
     this.isPg = this.exec.dialect === "postgres";
   }
   // ── dialect helpers ──────────────────────────────────────────────────────────────────────────
@@ -89,16 +109,33 @@ var DbTransport = class {
   }
   // ── schema ───────────────────────────────────────────────────────────────────────────────────
   ensureSchema() {
-    if (!this.schemaReady) this.schemaReady = this.createTables();
+    if (!this.schemaReady) {
+      this.schemaReady = this.createTables().catch((err) => {
+        this.schemaReady = void 0;
+        throw err;
+      });
+    }
     return this.schemaReady;
   }
+  /**
+  * Run one `CREATE … IF NOT EXISTS`. Two instances booting on a fresh database race it, and Postgres
+  * can reject the loser with a unique violation on its catalog even with `IF NOT EXISTS`; the
+  * statement is simply re-run, by which point the table exists and it is a no-op.
+  */
+  async createIfMissing(sql) {
+    try {
+      await this.exec.query(sql);
+    } catch {
+      await this.exec.query(sql);
+    }
+  }
   async createTables() {
     if (!this.autoCreate) return;
     const str = "varchar(191)";
     const txt = this.isPg ? "text" : "longtext";
     const tasks = this.q(this.tasksTable);
     const results = this.q(this.resultsTable);
-    await this.exec.query(`CREATE TABLE IF NOT EXISTS ${tasks} (
+    await this.createIfMissing(`CREATE TABLE IF NOT EXISTS ${tasks} (
         ${this.q("step_id")} ${str} PRIMARY KEY,
         ${this.q("run_id")} ${str} NOT NULL,
         ${this.q("seq")} integer NOT NULL,
@@ -111,7 +148,7 @@ var DbTransport = class {
         ${this.q("claimed_at")} bigint,
         ${this.q("created_at")} bigint NOT NULL
       )`);
-    await this.exec.query(`CREATE TABLE IF NOT EXISTS ${results} (
+    await this.createIfMissing(`CREATE TABLE IF NOT EXISTS ${results} (
         ${this.q("step_id")} ${str} PRIMARY KEY,
         ${this.q("run_id")} ${str} NOT NULL,
         ${this.q("seq")} integer NOT NULL,
@@ -123,6 +160,18 @@ var DbTransport = class {
         ${this.q("claimed_at")} bigint,
         ${this.q("created_at")} bigint NOT NULL
       )`);
+    await this.createIfMissing(`CREATE TABLE IF NOT EXISTS ${this.q(this.runsTable)} (
+        ${this.q("run_id")} ${str} PRIMARY KEY,
+        ${this.q("ns")} ${str} NOT NULL,
+        ${this.q("priority")} integer NOT NULL,
+        ${this.q("wake")} integer NOT NULL,
+        ${this.q("claimed_by")} ${str},
+        ${this.q("claim_token")} ${str},
+        ${this.q("claimed_at")} bigint,
+        ${this.q("created_at")} bigint NOT NULL
+      )`);
+    await this.exec.query(`CREATE INDEX ${this.q(`${this.runsTable}_ns_idx`)} ON ${this.q(this.runsTable)} (${this.q("ns")}, ${this.q("priority")}, ${this.q("created_at")})`).catch(() => {
+    });
     await this.exec.query(`CREATE INDEX ${this.q(`${this.tasksTable}_grp_idx`)} ON ${tasks} (${this.q("grp")}, ${this.q("status")}, ${this.q("created_at")})`).catch(() => {
     });
   }
@@ -166,26 +215,219 @@ var DbTransport = class {
   }
   onHeartbeat(_handler) {
   }
+  // ── run queue (engine ↔ engine) ─────────────────────────────────────────────────────────────
+  /**
+  * Queue `pending` runs for whichever engine instance polls the run queue first: one row per run,
+  * keyed by run id, so a run already waiting is not queued twice. A run whose row an instance holds
+  * right now is released for another take, so a dispatch landing while the run's previous entry is
+  * being handled is not lost when that entry is deleted. Up to {@link RUNS_INSERT_CHUNK} rows per
+  * insert.
+  */
+  async dispatchRuns(runs, opts) {
+    if (runs.length === 0) return;
+    await this.ensureSchema();
+    const byRun = /* @__PURE__ */ new Map();
+    for (const run of runs) {
+      if (!byRun.has(run.runId) || run.reason === "wake") byRun.set(run.runId, run);
+    }
+    const unique = [
+      ...byRun.values()
+    ];
+    const t = this.q(this.runsTable);
+    const cols = [
+      "run_id",
+      "ns",
+      "priority",
+      "wake",
+      "created_at"
+    ];
+    const now = this.now();
+    for (let at = 0; at < unique.length; at += RUNS_INSERT_CHUNK) {
+      const chunk = unique.slice(at, at + RUNS_INSERT_CHUNK);
+      const values = chunk.map((_, r) => `(${cols.map((__, c) => this.ph(r * cols.length + c + 1)).join(", ")})`).join(", ");
+      const insert = `INTO ${t} (${cols.map((c) => this.q(c)).join(", ")}) VALUES ${values}`;
+      const release = [
+        "claimed_by",
+        "claim_token",
+        "claimed_at"
+      ].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) => [
+        run.runId,
+        opts?.namespace ?? "",
+        run.priority ?? 0,
+        run.reason === "wake" ? 1 : 0,
+        now + r
+      ]));
+    }
+  }
+  /**
+  * Poll the run queue, at most `opts.concurrency` runs in flight on this instance. Rows are claimed
+  * with `FOR UPDATE SKIP LOCKED` (instances never take the same run), highest priority then oldest
+  * first; a row is deleted once its handler settles, and its lease is renewed meanwhile, so a row is
+  * re-taken only after the instance holding it went down. The returned stop takes no more rows and
+  * resolves once the runs in flight settled.
+  */
+  onDispatchedRun(handler, opts) {
+    const consumer = {
+      stopped: false,
+      inflight: /* @__PURE__ */ new Set(),
+      slotFreed: void 0,
+      loop: Promise.resolve()
+    };
+    const concurrency = Math.max(1, Math.floor(opts.concurrency));
+    const ns = opts.namespace ?? "";
+    consumer.loop = this.consumeRuns(consumer, handler, concurrency, ns).catch((err) => {
+      this.onError(err);
+    });
+    this.runConsumers.add(consumer);
+    return () => this.stopRunConsumer(consumer);
+  }
+  async stopRunConsumer(consumer) {
+    consumer.stopped = true;
+    consumer.slotFreed?.();
+    await consumer.loop;
+    this.runConsumers.delete(consumer);
+  }
+  async consumeRuns(consumer, handler, concurrency, ns) {
+    const renew = setInterval(() => void this.renewRunLeases(consumer).catch(() => void 0), Math.max(1e3, Math.floor(this.leaseMs / 3)));
+    renew.unref?.();
+    const settled = /* @__PURE__ */ new Set();
+    try {
+      while (this.running && !consumer.stopped) {
+        const free = concurrency - consumer.inflight.size;
+        if (free <= 0) {
+          await new Promise((resolve) => {
+            consumer.slotFreed = resolve;
+          });
+          consumer.slotFreed = void 0;
+          continue;
+        }
+        let rows = [];
+        try {
+          await this.ensureSchema();
+          rows = await 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)}`, [
+            token
+          ]).catch(() => void 0)).finally(() => {
+            consumer.inflight.delete(token);
+            settled.delete(done);
+            consumer.slotFreed?.();
+          });
+          settled.add(done);
+        }
+        if (rows.length === 0) await this.sleep(this.pollMs);
+      }
+      await Promise.allSettled([
+        ...settled
+      ]);
+    } finally {
+      clearInterval(renew);
+    }
+  }
+  async claimRuns(ns, limit) {
+    const t = this.q(this.runsTable);
+    const staleBefore = this.now() - this.leaseMs;
+    return this.exec.transaction(async (tx) => {
+      const rows = await tx.query(`SELECT ${this.q("run_id")}, ${this.q("wake")} FROM ${t}
+         WHERE ${this.q("ns")} = ${this.ph(1)}
+           AND (${this.q("claimed_at")} IS NULL OR ${this.q("claimed_at")} < ${this.ph(2)})
+         ORDER BY ${this.q("priority")} DESC, ${this.q("created_at")} ASC
+         LIMIT ${Math.floor(limit)} FOR UPDATE SKIP LOCKED`, [
+        ns,
+        staleBefore
+      ]);
+      const claimed = rows.map((r) => ({
+        run: {
+          runId: r.run_id,
+          reason: Number(r.wake) === 1 ? "wake" : "start"
+        },
+        token: globalThis.crypto.randomUUID()
+      }));
+      const now = this.now();
+      for (const { run: { runId }, token } of claimed) {
+        await tx.query(`UPDATE ${t} SET ${this.q("claimed_by")} = ${this.ph(1)}, ${this.q("claim_token")} = ${this.ph(2)}, ${this.q("claimed_at")} = ${this.ph(3)}
+           WHERE ${this.q("run_id")} = ${this.ph(4)}`, [
+          this.instanceId,
+          token,
+          now,
+          runId
+        ]);
+      }
+      return claimed;
+    });
+  }
+  /** Keep the rows of the runs in flight leased, so a long turn is not re-taken by another instance. */
+  async renewRunLeases(consumer) {
+    const tokens = [
+      ...consumer.inflight
+    ];
+    if (tokens.length === 0) return;
+    await this.exec.query(`UPDATE ${this.q(this.runsTable)} SET ${this.q("claimed_at")} = ${this.ph(1)}
+       WHERE ${this.q("claim_token")} IN (${tokens.map((_, i) => this.ph(i + 2)).join(", ")})`, [
+      this.now(),
+      ...tokens
+    ]);
+  }
   // ── polling ──────────────────────────────────────────────────────────────────────────────────
   /** Run `tick` repeatedly; sleep `pollMs` when it reports an empty queue. Stops on `close()`. */
   async loop(tick) {
-    await this.ensureSchema();
     while (this.running) {
       let processed = 0;
       try {
+        await this.ensureSchema();
         processed = await tick();
       } catch (err) {
-        if (this.running) console.error("[DbTransport] poll failed", err);
+        if (this.running) this.onError(err);
       }
-      if (processed === 0) await this.sleep(this.pollMs);
+      if (processed === 0 && this.running) await this.sleep(this.pollMs);
     }
   }
-  /** Claim a batch of tasks (FOR UPDATE SKIP LOCKED), then run each outside the lock. */
+  /**
+  * One task-loop round: claim as many rows as there are free slots (never more — a claimed row that
+  * isn't running is one an idle sibling can't run), and start each. With every slot busy, wait for
+  * one to free instead of polling.
+  */
   async drainTasks(group) {
-    const claimed = await this.claim(this.tasksTable, `${this.q("grp")} = ${this.ph(1)}`, [
+    const free = this.concurrency - this.runningTasks.size;
+    if (free <= 0) {
+      await Promise.race(this.runningTasks);
+      return 1;
+    }
+    const { rows, token } = await this.claim(this.tasksTable, Math.min(free, this.batchSize), `${this.q("grp")} = ${this.ph(1)}`, [
       group
     ]);
-    for (const row of claimed) {
+    if (rows.length === 0) return 0;
+    this.hold(this.tasksTable, token);
+    let left = rows.length;
+    for (const row of rows) {
+      const run = this.runTask(row, group, token).finally(() => {
+        this.runningTasks.delete(run);
+        left -= 1;
+        if (left === 0) this.release(this.tasksTable, token);
+      });
+      this.runningTasks.add(run);
+    }
+    return rows.length;
+  }
+  /**
+  * Run one claimed task and settle it — only while this instance still holds the claim: the claim is
+  * re-checked before running, and the task row is deleted and its result written in ONE transaction,
+  * conditional on the claim token, so an instance whose claim was taken over neither deletes the new
+  * holder's row nor publishes a second result.
+  */
+  async runTask(row, group, token) {
+    try {
+      if (!await this.stillHolds(row.step_id, token)) {
+        this.onError(new Error(`[DbTransport] lost the claim on task ${row.step_id} before running it \u2014 another instance took it over; not running it here`));
+        return;
+      }
       const task = {
         runId: row.run_id,
         seq: Number(row.seq),
@@ -196,62 +438,169 @@ var DbTransport = class {
         attempt: Number(row.attempt)
       };
       const result = await runStepHandler(task, this.handlers.get(task.name));
-      await this.insertResult(result);
-      await this.exec.query(`DELETE FROM ${this.q(this.tasksTable)} WHERE ${this.q("step_id")} = ${this.ph(1)}`, [
-        task.stepId
-      ]);
+      if (!await this.settleTask(task.stepId, token, result)) {
+        this.onError(new Error(`[DbTransport] lost the claim on task ${task.stepId} while running it (this instance went silent past leaseMs) \u2014 another instance took it over and may run it too; this run's result was dropped. Raise leaseMs if steps block the event loop`));
+      }
+    } catch (err) {
+      this.onError(err);
     }
-    return claimed.length;
   }
-  /** Claim a batch of results, deliver each to the engine, then delete it. */
-  async drainResults(handler) {
-    const claimed = await this.claim(this.resultsTable, "1 = 1", []);
-    for (const row of claimed) {
-      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)}`, [
-        result.stepId
+  /** Whether the claim on `stepId` is still `token`'s (re-stamping it if so). */
+  async stillHolds(stepId, token) {
+    const t = this.q(this.tasksTable);
+    const rows = await this.exec.transaction(async (tx) => {
+      const held = await tx.query(`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`, [
+        stepId,
+        token
       ]);
+      if (held.length > 0) {
+        await tx.query(`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)}`, [
+          this.now(),
+          stepId,
+          token
+        ]);
+      }
+      return held;
+    });
+    return rows.length > 0;
+  }
+  /** Delete the task row and publish its result in ONE transaction, only while `token` holds it. */
+  async settleTask(stepId, token, result) {
+    const t = this.q(this.tasksTable);
+    return this.exec.transaction(async (tx) => {
+      const held = await tx.query(`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`, [
+        stepId,
+        token
+      ]);
+      if (held.length === 0) return false;
+      await tx.query(`DELETE FROM ${t} WHERE ${this.q("step_id")} = ${this.ph(1)} AND ${this.q("claimed_by")} = ${this.ph(2)}`, [
+        stepId,
+        token
+      ]);
+      await this.insertResult(result, tx);
+      return true;
+    });
+  }
+  /**
+  * 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.
+  */
+  async drainResults(handler) {
+    const { rows, token } = await this.claim(this.resultsTable, this.batchSize, "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.release(this.resultsTable, token);
     }
-    return claimed.length;
+    return rows.length;
   }
   /**
-  * Atomically claim up to `batchSize` un-leased rows matching `where` and stamp them with this
-  * instance's lease. `SELECT … FOR UPDATE SKIP LOCKED` inside the txn means concurrent instances
-  * skip each other's locked rows instead of blocking, so no row is claimed twice.
+  * 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
+  * means concurrent instances skip each other's locked rows instead of blocking, so no row is
+  * claimed twice; the token is what every later delete/settle is conditional on.
   */
-  async claim(table, where, whereParams) {
+  async claim(table, limit, where, whereParams) {
     const t = this.q(table);
     const staleBefore = this.now() - this.leaseMs;
-    return this.exec.transaction(async (tx) => {
+    const token = `${this.instanceId}:${randomUUID()}`;
+    const rows = await this.exec.transaction(async (tx) => {
       const leaseClause = `(${this.q("claimed_at")} IS NULL OR ${this.q("claimed_at")} < ${this.ph(whereParams.length + 1)})`;
-      const rows = await tx.query(`SELECT * FROM ${t} WHERE ${where} AND ${leaseClause}
-         ORDER BY ${this.q("created_at")} ASC LIMIT ${this.batchSize} FOR UPDATE SKIP LOCKED`, [
+      const found = await tx.query(`SELECT * FROM ${t} WHERE ${where} AND ${leaseClause}
+         ORDER BY ${this.q("created_at")} ASC LIMIT ${Math.max(1, Math.floor(limit))} FOR UPDATE SKIP LOCKED`, [
         ...whereParams,
         staleBefore
       ]);
-      if (rows.length > 0) {
-        const ids = rows.map((r) => r.step_id);
+      if (found.length > 0) {
+        const ids = found.map((r) => r.step_id);
         const placeholders = ids.map((_, i) => this.ph(i + 3)).join(", ");
         await tx.query(`UPDATE ${t} SET ${this.q("claimed_by")} = ${this.ph(1)}, ${this.q("claimed_at")} = ${this.ph(2)}
            WHERE ${this.q("step_id")} IN (${placeholders})`, [
-          this.instanceId,
+          token,
           this.now(),
           ...ids
         ]);
       }
-      return rows;
+      return found;
     });
+    return {
+      rows,
+      token
+    };
+  }
+  // ── claim renewal: every claim held, not only the row being run ─────────────────────────────
+  hold(table, token) {
+    let tokens = this.held.get(table);
+    if (!tokens) {
+      tokens = /* @__PURE__ */ new Set();
+      this.held.set(table, tokens);
+    }
+    tokens.add(token);
+    if (this.renewTimer) return;
+    const intervalMs = Math.max(10, Math.floor(this.leaseMs / 3));
+    this.renewTimer = setInterval(() => {
+      if (this.renewal) return;
+      const round = this.renewHeld().catch((err) => this.onError(err)).finally(() => {
+        if (this.renewal === round) this.renewal = void 0;
+      });
+      this.renewal = round;
+    }, intervalMs);
+    this.renewTimer.unref?.();
   }
-  async insertResult(result) {
+  release(table, token) {
+    const tokens = this.held.get(table);
+    tokens?.delete(token);
+    if (tokens?.size === 0) this.held.delete(table);
+    if (this.held.size === 0 && this.renewTimer) {
+      clearInterval(this.renewTimer);
+      this.renewTimer = void 0;
+    }
+  }
+  /** Re-stamp `claimed_at` on every row still claimed under a token this instance holds. */
+  async renewHeld() {
+    for (const [table, tokens] of this.held) {
+      if (tokens.size === 0) continue;
+      const list = [
+        ...tokens
+      ];
+      const placeholders = list.map((_, i) => this.ph(i + 2)).join(", ");
+      await this.exec.query(`UPDATE ${this.q(table)} SET ${this.q("claimed_at")} = ${this.ph(1)} WHERE ${this.q("claimed_by")} IN (${placeholders})`, [
+        this.now(),
+        ...list
+      ]);
+    }
+  }
+  /**
+  * Write a result row. A result already waiting for the same step (an earlier attempt's, not yet
+  * deleted by the engine) is REPLACED and its claim reset, never kept: `step_id` is stable across
+  * attempts, so keeping the old row would silently drop a retry's result.
+  */
+  async insertResult(result, tx = this.exec) {
     const t = this.q(this.resultsTable);
     const cols = [
       "step_id",
@@ -263,9 +612,26 @@ var DbTransport = class {
       "started_at",
       "created_at"
     ];
-    const head = this.isPg ? `INSERT INTO ${t} (...) ON CONFLICT (${this.q("step_id")}) DO NOTHING` : `INSERT IGNORE INTO ${t} (...)`;
-    const sql = head.replace("(...)", `(${cols.map((c) => this.q(c)).join(", ")}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(", ")})`);
-    await this.exec.query(sql, [
+    const replace = [
+      "run_id",
+      "seq",
+      "status",
+      "output",
+      "error",
+      "started_at",
+      "created_at"
+    ];
+    const values = `(${cols.map((c) => this.q(c)).join(", ")}) VALUES (${cols.map((_, i) => this.ph(i + 1)).join(", ")})`;
+    const sql = this.isPg ? `INSERT INTO ${t} ${values} ON CONFLICT (${this.q("step_id")}) DO UPDATE SET ${[
+      ...replace.map((c) => `${this.q(c)} = EXCLUDED.${this.q(c)}`),
+      `${this.q("claimed_by")} = NULL`,
+      `${this.q("claimed_at")} = NULL`
+    ].join(", ")}` : `INSERT INTO ${t} ${values} ON DUPLICATE KEY UPDATE ${[
+      ...replace.map((c) => `${this.q(c)} = VALUES(${this.q(c)})`),
+      `${this.q("claimed_by")} = NULL`,
+      `${this.q("claimed_at")} = NULL`
+    ].join(", ")}`;
+    await tx.query(sql, [
       result.stepId,
       result.runId,
       result.seq,
@@ -284,8 +650,17 @@ var DbTransport = class {
     this.running = false;
     await Promise.allSettled([
       this.taskLoop,
-      this.resultLoop
+      this.resultLoop,
+      ...[
+        ...this.runConsumers
+      ].map((c) => this.stopRunConsumer(c))
+    ]);
+    await Promise.allSettled([
+      ...this.runningTasks
     ]);
+    if (this.renewTimer) clearInterval(this.renewTimer);
+    this.renewTimer = void 0;
+    await this.renewal;
   }
 };
 export {