@coji/durably 0.11.0 → 0.13.0

package/dist/index.js

@@ -4,6 +4,210 @@ import {
 
 // src/durably.ts
 import { Kysely } from "kysely";
+import { monotonicFactory as monotonicFactory2 } from "ulidx";
+
+// src/errors.ts
+var CancelledError = class extends Error {
+  constructor(runId) {
+    super(`Run was cancelled: ${runId}`);
+    this.name = "CancelledError";
+  }
+};
+var LeaseLostError = class extends Error {
+  constructor(runId) {
+    super(`Lease ownership was lost: ${runId}`);
+    this.name = "LeaseLostError";
+  }
+};
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/context.ts
+var LEASE_LOST = "lease-lost";
+function createStepContext(run, jobName, leaseGeneration, storage, eventEmitter) {
+  let stepIndex = run.currentStepIndex;
+  let currentStepName = null;
+  const controller = new AbortController();
+  function abortForLeaseLoss() {
+    if (!controller.signal.aborted) {
+      controller.abort(LEASE_LOST);
+    }
+  }
+  function throwIfAborted() {
+    if (!controller.signal.aborted) {
+      return;
+    }
+    if (controller.signal.reason === LEASE_LOST) {
+      throw new LeaseLostError(run.id);
+    }
+    throw new CancelledError(run.id);
+  }
+  const unsubscribe = eventEmitter.on("run:cancel", (event) => {
+    if (event.runId === run.id) {
+      controller.abort();
+    }
+  });
+  const step = {
+    get runId() {
+      return run.id;
+    },
+    get signal() {
+      return controller.signal;
+    },
+    isAborted() {
+      return controller.signal.aborted;
+    },
+    throwIfAborted() {
+      throwIfAborted();
+    },
+    async run(name, fn) {
+      throwIfAborted();
+      const currentRun = await storage.getRun(run.id);
+      if (currentRun?.status === "cancelled") {
+        controller.abort();
+        throwIfAborted();
+      }
+      if (currentRun && (currentRun.status === "leased" && currentRun.leaseGeneration !== leaseGeneration || currentRun.status === "completed" || currentRun.status === "failed")) {
+        abortForLeaseLoss();
+        throwIfAborted();
+      }
+      throwIfAborted();
+      const existingStep = await storage.getCompletedStep(run.id, name);
+      if (existingStep) {
+        stepIndex++;
+        return existingStep.output;
+      }
+      currentStepName = name;
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const startTime = Date.now();
+      eventEmitter.emit({
+        type: "step:start",
+        runId: run.id,
+        jobName,
+        stepName: name,
+        stepIndex,
+        labels: run.labels
+      });
+      try {
+        const result = await fn(controller.signal);
+        throwIfAborted();
+        const savedStep = await storage.persistStep(run.id, leaseGeneration, {
+          name,
+          index: stepIndex,
+          status: "completed",
+          output: result,
+          startedAt
+        });
+        if (!savedStep) {
+          abortForLeaseLoss();
+          throwIfAborted();
+        }
+        stepIndex++;
+        eventEmitter.emit({
+          type: "step:complete",
+          runId: run.id,
+          jobName,
+          stepName: name,
+          stepIndex: stepIndex - 1,
+          output: result,
+          duration: Date.now() - startTime,
+          labels: run.labels
+        });
+        return result;
+      } catch (error) {
+        if (error instanceof LeaseLostError) {
+          throw error;
+        }
+        const isLeaseLost = controller.signal.aborted && controller.signal.reason === LEASE_LOST;
+        if (isLeaseLost) {
+          throw new LeaseLostError(run.id);
+        }
+        const isCancelled = controller.signal.aborted;
+        const errorMessage = getErrorMessage(error);
+        const savedStep = await storage.persistStep(run.id, leaseGeneration, {
+          name,
+          index: stepIndex,
+          status: isCancelled ? "cancelled" : "failed",
+          error: errorMessage,
+          startedAt
+        });
+        if (!savedStep) {
+          abortForLeaseLoss();
+          throw new LeaseLostError(run.id);
+        }
+        eventEmitter.emit({
+          ...isCancelled ? { type: "step:cancel" } : { type: "step:fail", error: errorMessage },
+          runId: run.id,
+          jobName,
+          stepName: name,
+          stepIndex,
+          labels: run.labels
+        });
+        if (isCancelled) {
+          throwIfAborted();
+        }
+        throw error;
+      } finally {
+        currentStepName = null;
+      }
+    },
+    progress(current, total, message) {
+      const progressData = { current, total, message };
+      storage.updateProgress(run.id, leaseGeneration, progressData);
+      eventEmitter.emit({
+        type: "run:progress",
+        runId: run.id,
+        jobName,
+        progress: progressData,
+        labels: run.labels
+      });
+    },
+    log: {
+      info(message, data) {
+        eventEmitter.emit({
+          type: "log:write",
+          runId: run.id,
+          jobName,
+          labels: run.labels,
+          stepName: currentStepName,
+          level: "info",
+          message,
+          data
+        });
+      },
+      warn(message, data) {
+        eventEmitter.emit({
+          type: "log:write",
+          runId: run.id,
+          jobName,
+          labels: run.labels,
+          stepName: currentStepName,
+          level: "warn",
+          message,
+          data
+        });
+      },
+      error(message, data) {
+        eventEmitter.emit({
+          type: "log:write",
+          runId: run.id,
+          jobName,
+          labels: run.labels,
+          stepName: currentStepName,
+          level: "error",
+          message,
+          data
+        });
+      }
+    }
+  };
+  return {
+    step,
+    abortLeaseOwnership: abortForLeaseLoss,
+    dispose: unsubscribe
+  };
+}
 
 // src/events.ts
 function createEventEmitter() {
@@ -96,7 +300,7 @@ function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema)
       if (labelsSchema && options?.labels) {
         validateJobInputOrThrow(labelsSchema, options.labels, "labels");
       }
-      const run = await storage.createRun({
+      const run = await storage.enqueue({
         jobName: jobDef.name,
         input: validatedInput,
         idempotencyKey: options?.idempotencyKey,
@@ -226,7 +430,7 @@ function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema)
           options: normalized[i].options
         });
       }
-      const runs = await storage.batchCreateRuns(
+      const runs = await storage.enqueueMany(
         validated.map((v) => ({
           jobName: jobDef.name,
           input: v.input,
@@ -274,6 +478,7 @@ function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema)
 }
 
 // src/migrations.ts
+import { sql } from "kysely";
 var migrations = [
   {
     version: 1,
@@ -282,12 +487,26 @@ var migrations = [
         "current_step_index",
         "integer",
         (col) => col.notNull().defaultTo(0)
-      ).addColumn("progress", "text").addColumn("output", "text").addColumn("error", "text").addColumn("heartbeat_at", "text", (col) => col.notNull()).addColumn("started_at", "text").addColumn("completed_at", "text").addColumn("created_at", "text", (col) => col.notNull()).addColumn("updated_at", "text", (col) => col.notNull()).execute();
+      ).addColumn("progress", "text").addColumn("output", "text").addColumn("error", "text").addColumn("lease_owner", "text").addColumn("lease_expires_at", "text").addColumn(
+        "lease_generation",
+        "integer",
+        (col) => col.notNull().defaultTo(0)
+      ).addColumn("started_at", "text").addColumn("completed_at", "text").addColumn("created_at", "text", (col) => col.notNull()).addColumn("updated_at", "text", (col) => col.notNull()).execute();
       await db.schema.createIndex("idx_durably_runs_job_idempotency").ifNotExists().on("durably_runs").columns(["job_name", "idempotency_key"]).unique().execute();
       await db.schema.createIndex("idx_durably_runs_status_concurrency").ifNotExists().on("durably_runs").columns(["status", "concurrency_key"]).execute();
       await db.schema.createIndex("idx_durably_runs_status_created").ifNotExists().on("durably_runs").columns(["status", "created_at"]).execute();
+      await db.schema.createIndex("idx_durably_runs_status_lease_expires").ifNotExists().on("durably_runs").columns(["status", "lease_expires_at"]).execute();
+      await db.schema.createIndex("idx_durably_runs_job_created").ifNotExists().on("durably_runs").columns(["job_name", "created_at"]).execute();
+      await db.schema.createIndex("idx_durably_runs_status_completed").ifNotExists().on("durably_runs").columns(["status", "completed_at"]).execute();
+      await db.schema.createTable("durably_run_labels").ifNotExists().addColumn("run_id", "text", (col) => col.notNull()).addColumn("key", "text", (col) => col.notNull()).addColumn("value", "text", (col) => col.notNull()).execute();
+      await db.schema.createIndex("idx_durably_run_labels_pk").ifNotExists().on("durably_run_labels").columns(["run_id", "key"]).unique().execute();
+      await db.schema.createIndex("idx_durably_run_labels_key_value").ifNotExists().on("durably_run_labels").columns(["key", "value"]).execute();
       await db.schema.createTable("durably_steps").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("run_id", "text", (col) => col.notNull()).addColumn("name", "text", (col) => col.notNull()).addColumn("index", "integer", (col) => col.notNull()).addColumn("status", "text", (col) => col.notNull()).addColumn("output", "text").addColumn("error", "text").addColumn("started_at", "text", (col) => col.notNull()).addColumn("completed_at", "text").execute();
       await db.schema.createIndex("idx_durably_steps_run_index").ifNotExists().on("durably_steps").columns(["run_id", "index"]).execute();
+      await sql`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_durably_steps_completed_unique
+        ON durably_steps(run_id, name) WHERE status = 'completed'
+      `.execute(db);
       await db.schema.createTable("durably_logs").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("run_id", "text", (col) => col.notNull()).addColumn("step_name", "text").addColumn("level", "text", (col) => col.notNull()).addColumn("message", "text", (col) => col.notNull()).addColumn("data", "text").addColumn("created_at", "text", (col) => col.notNull()).execute();
       await db.schema.createIndex("idx_durably_logs_run_created").ifNotExists().on("durably_logs").columns(["run_id", "created_at"]).execute();
       await db.schema.createTable("durably_schema_versions").ifNotExists().addColumn("version", "integer", (col) => col.primaryKey()).addColumn("applied_at", "text", (col) => col.notNull()).execute();
@@ -318,14 +537,17 @@ async function runMigrations(db) {
 }
 
 // src/storage.ts
-import { sql } from "kysely";
+import { sql as sql2 } from "kysely";
 import { monotonicFactory } from "ulidx";
 var ulid = monotonicFactory();
+var TERMINAL_STATUSES = ["completed", "failed", "cancelled"];
 function toClientRun(run) {
   const {
     idempotencyKey,
     concurrencyKey,
-    heartbeatAt,
+    leaseOwner,
+    leaseExpiresAt,
+    leaseGeneration,
     updatedAt,
     ...clientRun
   } = run;
@@ -356,7 +578,9 @@ function rowToRun(row) {
     output: row.output ? JSON.parse(row.output) : null,
     error: row.error,
     labels: JSON.parse(row.labels),
-    heartbeatAt: row.heartbeat_at,
+    leaseOwner: row.lease_owner,
+    leaseExpiresAt: row.lease_expires_at,
+    leaseGeneration: row.lease_generation,
     startedAt: row.started_at,
     completedAt: row.completed_at,
     createdAt: row.created_at,
@@ -387,9 +611,50 @@ function rowToLog(row) {
     createdAt: row.created_at
   };
 }
-function createKyselyStorage(db) {
-  return {
-    async createRun(input) {
+function createWriteMutex() {
+  let queue = Promise.resolve();
+  return async function withWriteLock(fn) {
+    let release;
+    const next = new Promise((resolve) => {
+      release = resolve;
+    });
+    const prev = queue;
+    queue = next;
+    await prev;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  };
+}
+function createKyselyStore(db, backend = "generic") {
+  const withWriteLock = createWriteMutex();
+  async function cascadeDeleteRuns(trx, ids) {
+    if (ids.length === 0) return;
+    await trx.deleteFrom("durably_steps").where("run_id", "in", ids).execute();
+    await trx.deleteFrom("durably_logs").where("run_id", "in", ids).execute();
+    await trx.deleteFrom("durably_run_labels").where("run_id", "in", ids).execute();
+    await trx.deleteFrom("durably_runs").where("id", "in", ids).execute();
+  }
+  async function insertLabelRows(executor, runId, labels) {
+    const entries = Object.entries(labels ?? {});
+    if (entries.length > 0) {
+      await executor.insertInto("durably_run_labels").values(entries.map(([key, value]) => ({ run_id: runId, key, value }))).execute();
+    }
+  }
+  async function terminateRun(runId, leaseGeneration, completedAt, fields) {
+    const result = await db.updateTable("durably_runs").set({
+      ...fields,
+      lease_owner: null,
+      lease_expires_at: null,
+      completed_at: completedAt,
+      updated_at: completedAt
+    }).where("id", "=", runId).where("status", "=", "leased").where("lease_generation", "=", leaseGeneration).executeTakeFirst();
+    return Number(result.numUpdatedRows) > 0;
+  }
+  const store = {
+    async enqueue(input) {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       if (input.idempotencyKey) {
         const existing = await db.selectFrom("durably_runs").selectAll().where("job_name", "=", input.jobName).where("idempotency_key", "=", input.idempotencyKey).executeTakeFirst();
@@ -411,16 +676,21 @@ function createKyselyStorage(db) {
         output: null,
         error: null,
         labels: JSON.stringify(input.labels ?? {}),
-        heartbeat_at: now,
+        lease_owner: null,
+        lease_expires_at: null,
+        lease_generation: 0,
         started_at: null,
         completed_at: null,
         created_at: now,
         updated_at: now
       };
-      await db.insertInto("durably_runs").values(run).execute();
+      await db.transaction().execute(async (trx) => {
+        await trx.insertInto("durably_runs").values(run).execute();
+        await insertLabelRows(trx, id, input.labels);
+      });
       return rowToRun(run);
     },
-    async batchCreateRuns(inputs) {
+    async enqueueMany(inputs) {
       if (inputs.length === 0) {
         return [];
       }
@@ -430,6 +700,7 @@ function createKyselyStorage(db) {
         for (const input of inputs) {
           validateLabels(input.labels);
         }
+        const allLabelRows = [];
         for (const input of inputs) {
           if (input.idempotencyKey) {
             const existing = await trx.selectFrom("durably_runs").selectAll().where("job_name", "=", input.jobName).where("idempotency_key", "=", input.idempotencyKey).executeTakeFirst();
@@ -439,6 +710,11 @@ function createKyselyStorage(db) {
             }
           }
           const id = ulid();
+          if (input.labels) {
+            for (const [key, value] of Object.entries(input.labels)) {
+              allLabelRows.push({ run_id: id, key, value });
+            }
+          }
           runs.push({
             id,
             job_name: input.jobName,
@@ -451,7 +727,9 @@ function createKyselyStorage(db) {
             output: null,
             error: null,
             labels: JSON.stringify(input.labels ?? {}),
-            heartbeat_at: now,
+            lease_owner: null,
+            lease_expires_at: null,
+            lease_generation: 0,
             started_at: null,
             completed_at: null,
             created_at: now,
@@ -461,35 +739,13 @@ function createKyselyStorage(db) {
         const newRuns = runs.filter((r) => r.created_at === now);
         if (newRuns.length > 0) {
           await trx.insertInto("durably_runs").values(newRuns).execute();
+          if (allLabelRows.length > 0) {
+            await trx.insertInto("durably_run_labels").values(allLabelRows).execute();
+          }
         }
         return runs.map(rowToRun);
       });
     },
-    async updateRun(runId, data) {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const updates = {
-        updated_at: now
-      };
-      if (data.status !== void 0) updates.status = data.status;
-      if (data.currentStepIndex !== void 0)
-        updates.current_step_index = data.currentStepIndex;
-      if (data.progress !== void 0)
-        updates.progress = data.progress ? JSON.stringify(data.progress) : null;
-      if (data.output !== void 0)
-        updates.output = JSON.stringify(data.output);
-      if (data.error !== void 0) updates.error = data.error;
-      if (data.heartbeatAt !== void 0)
-        updates.heartbeat_at = data.heartbeatAt;
-      if (data.startedAt !== void 0) updates.started_at = data.startedAt;
-      if (data.completedAt !== void 0)
-        updates.completed_at = data.completedAt;
-      await db.updateTable("durably_runs").set(updates).where("id", "=", runId).execute();
-    },
-    async deleteRun(runId) {
-      await db.deleteFrom("durably_logs").where("run_id", "=", runId).execute();
-      await db.deleteFrom("durably_steps").where("run_id", "=", runId).execute();
-      await db.deleteFrom("durably_runs").where("id", "=", runId).execute();
-    },
     async getRun(runId) {
       const row = await db.selectFrom("durably_runs").leftJoin("durably_steps", "durably_runs.id", "durably_steps.run_id").selectAll("durably_runs").select(
         (eb) => eb.fn.count("durably_steps.id").as("step_count")
@@ -517,10 +773,14 @@ function createKyselyStorage(db) {
         validateLabels(labels);
         for (const [key, value] of Object.entries(labels)) {
           if (value === void 0) continue;
+          const jsonFallback = backend === "postgres" ? sql2`durably_runs.labels ->> ${key} = ${value}` : sql2`json_extract(durably_runs.labels, ${`$.${key}`}) = ${value}`;
           query = query.where(
-            sql`json_extract(durably_runs.labels, ${`$."${key}"`})`,
-            "=",
-            value
+            (eb) => eb.or([
+              eb.exists(
+                eb.selectFrom("durably_run_labels").select(sql2.lit(1).as("one")).whereRef("durably_run_labels.run_id", "=", "durably_runs.id").where("durably_run_labels.key", "=", key).where("durably_run_labels.value", "=", value)
+              ),
+              jsonFallback
+            ])
           );
         }
       }
@@ -537,21 +797,131 @@ function createKyselyStorage(db) {
       const rows = await query.execute();
       return rows.map(rowToRun);
     },
-    async claimNextPendingRun(excludeConcurrencyKeys) {
+    async updateRun(runId, data) {
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      let subquery = db.selectFrom("durably_runs").select("id").where("status", "=", "pending").orderBy("created_at", "asc").orderBy("id", "asc").limit(1);
-      if (excludeConcurrencyKeys.length > 0) {
-        subquery = subquery.where(
-          (eb) => eb.or([
-            eb("concurrency_key", "is", null),
-            eb("concurrency_key", "not in", excludeConcurrencyKeys)
-          ])
-        );
+      const status = data.status;
+      await db.updateTable("durably_runs").set({
+        status,
+        current_step_index: data.currentStepIndex,
+        progress: data.progress !== void 0 ? data.progress ? JSON.stringify(data.progress) : null : void 0,
+        output: data.output !== void 0 ? JSON.stringify(data.output) : void 0,
+        error: data.error,
+        lease_owner: data.leaseOwner !== void 0 ? data.leaseOwner : void 0,
+        lease_expires_at: data.leaseExpiresAt !== void 0 ? data.leaseExpiresAt : void 0,
+        started_at: data.startedAt,
+        completed_at: data.completedAt,
+        updated_at: now
+      }).where("id", "=", runId).execute();
+    },
+    async deleteRun(runId) {
+      await db.transaction().execute(async (trx) => {
+        await cascadeDeleteRuns(trx, [runId]);
+      });
+    },
+    async purgeRuns(options) {
+      const limit = options.limit ?? 500;
+      return await db.transaction().execute(async (trx) => {
+        const rows = await trx.selectFrom("durably_runs").select("id").where("status", "in", TERMINAL_STATUSES).where("completed_at", "<", options.olderThan).orderBy("completed_at", "asc").limit(limit).execute();
+        if (rows.length === 0) return 0;
+        const ids = rows.map((r) => r.id);
+        await cascadeDeleteRuns(trx, ids);
+        return ids.length;
+      });
+    },
+    async claimNext(workerId, now, leaseMs) {
+      const leaseExpiresAt = new Date(Date.parse(now) + leaseMs).toISOString();
+      const activeLeaseGuard = sql2`
+        (
+          concurrency_key IS NULL
+          OR NOT EXISTS (
+            SELECT 1
+            FROM durably_runs AS active
+            WHERE active.concurrency_key = durably_runs.concurrency_key
+              AND active.id <> durably_runs.id
+              AND active.status = 'leased'
+              AND active.lease_expires_at IS NOT NULL
+              AND active.lease_expires_at > ${now}
+          )
+        )
+      `;
+      if (backend === "postgres") {
+        return await db.transaction().execute(async (trx) => {
+          const skipKeys = [];
+          for (; ; ) {
+            const concurrencyCondition = skipKeys.length > 0 ? sql2`
+                    AND (
+                      concurrency_key IS NULL
+                      OR concurrency_key NOT IN (${sql2.join(skipKeys)})
+                    )
+                  ` : sql2``;
+            const candidateResult = await sql2`
+              SELECT id, concurrency_key
+              FROM durably_runs
+              WHERE
+                (
+                  status = 'pending'
+                  OR (status = 'leased' AND lease_expires_at IS NOT NULL AND lease_expires_at <= ${now})
+                )
+                AND ${activeLeaseGuard}
+                ${concurrencyCondition}
+              ORDER BY created_at ASC, id ASC
+              FOR UPDATE SKIP LOCKED
+              LIMIT 1
+            `.execute(trx);
+            const candidate = candidateResult.rows[0];
+            if (!candidate) return null;
+            if (candidate.concurrency_key) {
+              await sql2`SELECT pg_advisory_xact_lock(hashtext(${candidate.concurrency_key}))`.execute(
+                trx
+              );
+              const conflict = await sql2`
+                SELECT 1 FROM durably_runs
+                WHERE concurrency_key = ${candidate.concurrency_key}
+                  AND id <> ${candidate.id}
+                  AND status = 'leased'
+                  AND lease_expires_at IS NOT NULL
+                  AND lease_expires_at > ${now}
+                LIMIT 1
+              `.execute(trx);
+              if (conflict.rows.length > 0) {
+                skipKeys.push(candidate.concurrency_key);
+                continue;
+              }
+            }
+            const result = await sql2`
+              UPDATE durably_runs
+              SET
+                status = 'leased',
+                lease_owner = ${workerId},
+                lease_expires_at = ${leaseExpiresAt},
+                lease_generation = lease_generation + 1,
+                started_at = COALESCE(started_at, ${now}),
+                updated_at = ${now}
+              WHERE id = ${candidate.id}
+              RETURNING *
+            `.execute(trx);
+            const row2 = result.rows[0];
+            if (!row2) return null;
+            return rowToRun({ ...row2, step_count: 0 });
+          }
+        });
       }
+      let subquery = db.selectFrom("durably_runs").select("durably_runs.id").where(
+        (eb) => eb.or([
+          eb("status", "=", "pending"),
+          eb.and([
+            eb("status", "=", "leased"),
+            eb("lease_expires_at", "is not", null),
+            eb("lease_expires_at", "<=", now)
+          ])
+        ])
+      ).where(activeLeaseGuard).orderBy("created_at", "asc").orderBy("id", "asc").limit(1);
       const row = await db.updateTable("durably_runs").set({
-        status: "running",
-        heartbeat_at: now,
-        started_at: sql`COALESCE(started_at, ${now})`,
+        status: "leased",
+        lease_owner: workerId,
+        lease_expires_at: leaseExpiresAt,
+        lease_generation: sql2`lease_generation + 1`,
+        started_at: sql2`COALESCE(started_at, ${now})`,
         updated_at: now
       }).where(
         "id",
@@ -561,367 +931,165 @@ function createKyselyStorage(db) {
       if (!row) return null;
       return rowToRun({ ...row, step_count: 0 });
     },
-    async createStep(input) {
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const id = ulid();
-      const step = {
-        id,
-        run_id: input.runId,
-        name: input.name,
-        index: input.index,
-        status: input.status,
-        output: input.output !== void 0 ? JSON.stringify(input.output) : null,
-        error: input.error ?? null,
-        started_at: input.startedAt,
-        completed_at: completedAt
-      };
-      await db.insertInto("durably_steps").values(step).execute();
-      return rowToStep(step);
+    async renewLease(runId, leaseGeneration, now, leaseMs) {
+      const leaseExpiresAt = new Date(Date.parse(now) + leaseMs).toISOString();
+      const result = await db.updateTable("durably_runs").set({
+        lease_expires_at: leaseExpiresAt,
+        updated_at: now
+      }).where("id", "=", runId).where("status", "=", "leased").where("lease_generation", "=", leaseGeneration).where("lease_expires_at", ">", now).executeTakeFirst();
+      return Number(result.numUpdatedRows) > 0;
     },
-    async getSteps(runId) {
-      const rows = await db.selectFrom("durably_steps").selectAll().where("run_id", "=", runId).orderBy("index", "asc").execute();
-      return rows.map(rowToStep);
+    async releaseExpiredLeases(now) {
+      const result = await db.updateTable("durably_runs").set({
+        status: "pending",
+        lease_owner: null,
+        lease_expires_at: null,
+        updated_at: now
+      }).where("status", "=", "leased").where("lease_expires_at", "is not", null).where("lease_expires_at", "<=", now).executeTakeFirst();
+      return Number(result.numUpdatedRows);
     },
-    async getCompletedStep(runId, name) {
-      const row = await db.selectFrom("durably_steps").selectAll().where("run_id", "=", runId).where("name", "=", name).where("status", "=", "completed").executeTakeFirst();
-      return row ? rowToStep(row) : null;
+    async completeRun(runId, leaseGeneration, output, completedAt) {
+      return terminateRun(runId, leaseGeneration, completedAt, {
+        status: "completed",
+        output: JSON.stringify(output),
+        error: null
+      });
     },
-    async createLog(input) {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const id = ulid();
-      const log = {
-        id,
-        run_id: input.runId,
-        step_name: input.stepName,
-        level: input.level,
-        message: input.message,
-        data: input.data !== void 0 ? JSON.stringify(input.data) : null,
-        created_at: now
-      };
-      await db.insertInto("durably_logs").values(log).execute();
-      return rowToLog(log);
+    async failRun(runId, leaseGeneration, error, completedAt) {
+      return terminateRun(runId, leaseGeneration, completedAt, {
+        status: "failed",
+        error
+      });
     },
-    async getLogs(runId) {
-      const rows = await db.selectFrom("durably_logs").selectAll().where("run_id", "=", runId).orderBy("created_at", "asc").execute();
-      return rows.map(rowToLog);
-    }
-  };
-}
-
-// src/worker.ts
-import { prettifyError as prettifyError2 } from "zod";
-
-// src/errors.ts
-var CancelledError = class extends Error {
-  constructor(runId) {
-    super(`Run was cancelled: ${runId}`);
-    this.name = "CancelledError";
-  }
-};
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/context.ts
-function createStepContext(run, jobName, storage, eventEmitter) {
-  let stepIndex = run.currentStepIndex;
-  let currentStepName = null;
-  const controller = new AbortController();
-  const unsubscribe = eventEmitter.on("run:cancel", (event) => {
-    if (event.runId === run.id) {
-      controller.abort();
-    }
-  });
-  const step = {
-    get runId() {
-      return run.id;
+    async cancelRun(runId, now) {
+      const result = await db.updateTable("durably_runs").set({
+        status: "cancelled",
+        lease_owner: null,
+        lease_expires_at: null,
+        completed_at: now,
+        updated_at: now
+      }).where("id", "=", runId).where("status", "in", ["pending", "leased"]).executeTakeFirst();
+      return Number(result.numUpdatedRows) > 0;
     },
-    async run(name, fn) {
-      if (controller.signal.aborted) {
-        throw new CancelledError(run.id);
-      }
-      const currentRun = await storage.getRun(run.id);
-      if (currentRun?.status === "cancelled") {
-        controller.abort();
-        throw new CancelledError(run.id);
-      }
-      if (controller.signal.aborted) {
-        throw new CancelledError(run.id);
-      }
-      const existingStep = await storage.getCompletedStep(run.id, name);
-      if (existingStep) {
-        stepIndex++;
-        return existingStep.output;
-      }
-      currentStepName = name;
-      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const startTime = Date.now();
-      eventEmitter.emit({
-        type: "step:start",
-        runId: run.id,
-        jobName,
-        stepName: name,
-        stepIndex,
-        labels: run.labels
-      });
-      try {
-        const result = await fn(controller.signal);
-        await storage.createStep({
-          runId: run.id,
-          name,
-          index: stepIndex,
-          status: "completed",
-          output: result,
-          startedAt
-        });
-        stepIndex++;
-        await storage.updateRun(run.id, { currentStepIndex: stepIndex });
-        eventEmitter.emit({
-          type: "step:complete",
-          runId: run.id,
-          jobName,
-          stepName: name,
-          stepIndex: stepIndex - 1,
-          output: result,
-          duration: Date.now() - startTime,
-          labels: run.labels
-        });
-        return result;
-      } catch (error) {
-        const isCancelled = controller.signal.aborted;
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        await storage.createStep({
-          runId: run.id,
-          name,
-          index: stepIndex,
-          status: isCancelled ? "cancelled" : "failed",
-          error: errorMessage,
-          startedAt
-        });
-        eventEmitter.emit({
-          ...isCancelled ? { type: "step:cancel" } : { type: "step:fail", error: errorMessage },
-          runId: run.id,
-          jobName,
-          stepName: name,
-          stepIndex,
-          labels: run.labels
-        });
-        if (isCancelled) {
-          throw new CancelledError(run.id);
+    async persistStep(runId, leaseGeneration, input) {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const id = ulid();
+      const outputJson = input.output !== void 0 ? JSON.stringify(input.output) : null;
+      const errorValue = input.error ?? null;
+      return await db.transaction().execute(async (trx) => {
+        const insertResult = await sql2`
+          INSERT INTO durably_steps (id, run_id, name, "index", status, output, error, started_at, completed_at)
+          SELECT ${id}, ${runId}, ${input.name}, ${input.index}, ${input.status},
+                 ${outputJson}, ${errorValue}, ${input.startedAt}, ${completedAt}
+          FROM durably_runs
+          WHERE id = ${runId} AND lease_generation = ${leaseGeneration}
+        `.execute(trx);
+        if (Number(insertResult.numAffectedRows) === 0) return null;
+        if (input.status === "completed") {
+          await trx.updateTable("durably_runs").set({
+            current_step_index: input.index + 1,
+            updated_at: completedAt
+          }).where("id", "=", runId).where("lease_generation", "=", leaseGeneration).execute();
         }
-        throw error;
-      } finally {
-        currentStepName = null;
-      }
-    },
-    progress(current, total, message) {
-      const progressData = { current, total, message };
-      storage.updateRun(run.id, { progress: progressData });
-      eventEmitter.emit({
-        type: "run:progress",
-        runId: run.id,
-        jobName,
-        progress: progressData,
-        labels: run.labels
+        return {
+          id,
+          runId,
+          name: input.name,
+          index: input.index,
+          status: input.status,
+          output: input.output !== void 0 ? input.output : null,
+          error: errorValue,
+          startedAt: input.startedAt,
+          completedAt
+        };
       });
     },
-    log: {
-      info(message, data) {
-        eventEmitter.emit({
-          type: "log:write",
-          runId: run.id,
-          jobName,
-          labels: run.labels,
-          stepName: currentStepName,
-          level: "info",
-          message,
-          data
-        });
-      },
-      warn(message, data) {
-        eventEmitter.emit({
-          type: "log:write",
-          runId: run.id,
-          jobName,
-          labels: run.labels,
-          stepName: currentStepName,
-          level: "warn",
-          message,
-          data
-        });
-      },
-      error(message, data) {
-        eventEmitter.emit({
-          type: "log:write",
-          runId: run.id,
-          jobName,
-          labels: run.labels,
-          stepName: currentStepName,
-          level: "error",
-          message,
-          data
-        });
-      }
+    async deleteSteps(runId) {
+      await db.deleteFrom("durably_steps").where("run_id", "=", runId).execute();
+      await db.deleteFrom("durably_logs").where("run_id", "=", runId).execute();
+    },
+    async getSteps(runId) {
+      const rows = await db.selectFrom("durably_steps").selectAll().where("run_id", "=", runId).orderBy("index", "asc").execute();
+      return rows.map(rowToStep);
+    },
+    async getCompletedStep(runId, name) {
+      const row = await db.selectFrom("durably_steps").selectAll().where("run_id", "=", runId).where("name", "=", name).where("status", "=", "completed").executeTakeFirst();
+      return row ? rowToStep(row) : null;
+    },
+    async updateProgress(runId, leaseGeneration, progress) {
+      await db.updateTable("durably_runs").set({
+        progress: progress ? JSON.stringify(progress) : null,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).where("id", "=", runId).where("lease_generation", "=", leaseGeneration).execute();
+    },
+    async createLog(input) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const id = ulid();
+      const log = {
+        id,
+        run_id: input.runId,
+        step_name: input.stepName,
+        level: input.level,
+        message: input.message,
+        data: input.data !== void 0 ? JSON.stringify(input.data) : null,
+        created_at: now
+      };
+      await db.insertInto("durably_logs").values(log).execute();
+      return rowToLog(log);
+    },
+    async getLogs(runId) {
+      const rows = await db.selectFrom("durably_logs").selectAll().where("run_id", "=", runId).orderBy("created_at", "asc").execute();
+      return rows.map(rowToLog);
     }
   };
-  return { step, dispose: unsubscribe };
+  const mutatingKeys = [
+    "enqueue",
+    "enqueueMany",
+    "updateRun",
+    "deleteRun",
+    "purgeRuns",
+    "claimNext",
+    "renewLease",
+    "releaseExpiredLeases",
+    "completeRun",
+    "failRun",
+    "cancelRun",
+    "persistStep",
+    "deleteSteps",
+    "updateProgress",
+    "createLog"
+  ];
+  for (const key of mutatingKeys) {
+    const original = store[key];
+    store[key] = (...args) => withWriteLock(() => original.apply(store, args));
+  }
+  return store;
 }
 
 // src/worker.ts
-function createWorker(config, storage, eventEmitter, jobRegistry) {
+function createWorker(config, processOne) {
   let running = false;
-  let currentRunPromise = null;
   let pollingTimeout = null;
+  let inFlight = null;
   let stopResolver = null;
-  let heartbeatInterval = null;
-  let currentRunId = null;
-  async function recoverStaleRuns() {
-    const staleThreshold = new Date(
-      Date.now() - config.staleThreshold
-    ).toISOString();
-    const runningRuns = await storage.getRuns({ status: "running" });
-    for (const run of runningRuns) {
-      if (run.heartbeatAt < staleThreshold) {
-        await storage.updateRun(run.id, {
-          status: "pending"
-        });
-      }
-    }
-  }
-  async function updateHeartbeat() {
-    if (currentRunId) {
-      await storage.updateRun(currentRunId, {
-        heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-  }
-  async function handleRunSuccess(runId, jobName, output, startTime) {
-    const currentRun = await storage.getRun(runId);
-    if (!currentRun || currentRun.status === "cancelled") {
-      return;
-    }
-    await storage.updateRun(runId, {
-      status: "completed",
-      output,
-      completedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    eventEmitter.emit({
-      type: "run:complete",
-      runId,
-      jobName,
-      output,
-      duration: Date.now() - startTime,
-      labels: currentRun.labels
-    });
-  }
-  async function handleRunFailure(runId, jobName, error) {
-    if (error instanceof CancelledError) {
-      return;
-    }
-    const currentRun = await storage.getRun(runId);
-    if (!currentRun || currentRun.status === "cancelled") {
-      return;
-    }
-    const errorMessage = getErrorMessage(error);
-    const steps = await storage.getSteps(runId);
-    const failedStep = steps.find((s) => s.status === "failed");
-    await storage.updateRun(runId, {
-      status: "failed",
-      error: errorMessage,
-      completedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    eventEmitter.emit({
-      type: "run:fail",
-      runId,
-      jobName,
-      error: errorMessage,
-      failedStepName: failedStep?.name ?? "unknown",
-      labels: currentRun.labels
-    });
-  }
-  async function executeRun(run, job) {
-    currentRunId = run.id;
-    heartbeatInterval = setInterval(() => {
-      updateHeartbeat().catch((error) => {
-        eventEmitter.emit({
-          type: "worker:error",
-          error: getErrorMessage(error),
-          context: "heartbeat",
-          runId: run.id
-        });
-      });
-    }, config.heartbeatInterval);
-    eventEmitter.emit({
-      type: "run:start",
-      runId: run.id,
-      jobName: run.jobName,
-      input: run.input,
-      labels: run.labels
-    });
-    const startTime = Date.now();
-    const { step, dispose } = createStepContext(
-      run,
-      run.jobName,
-      storage,
-      eventEmitter
-    );
-    try {
-      const output = await job.fn(step, run.input);
-      if (job.outputSchema) {
-        const parseResult = job.outputSchema.safeParse(output);
-        if (!parseResult.success) {
-          throw new Error(`Invalid output: ${prettifyError2(parseResult.error)}`);
-        }
-      }
-      await handleRunSuccess(run.id, run.jobName, output, startTime);
-    } catch (error) {
-      await handleRunFailure(run.id, run.jobName, error);
-    } finally {
-      dispose();
-      if (heartbeatInterval) {
-        clearInterval(heartbeatInterval);
-        heartbeatInterval = null;
-      }
-      currentRunId = null;
-    }
-  }
-  async function processNextRun() {
-    const runningRuns = await storage.getRuns({ status: "running" });
-    const excludeConcurrencyKeys = runningRuns.filter(
-      (r) => r.concurrencyKey !== null
-    ).map((r) => r.concurrencyKey);
-    const run = await storage.claimNextPendingRun(excludeConcurrencyKeys);
-    if (!run) {
-      return false;
-    }
-    const job = jobRegistry.get(run.jobName);
-    if (!job) {
-      await storage.updateRun(run.id, {
-        status: "failed",
-        error: `Unknown job: ${run.jobName}`
-      });
-      return true;
-    }
-    await executeRun(run, job);
-    return true;
-  }
+  let activeWorkerId;
   async function poll() {
     if (!running) {
       return;
     }
-    const doWork = async () => {
-      await recoverStaleRuns();
-      await processNextRun();
-    };
     try {
-      currentRunPromise = doWork();
-      await currentRunPromise;
+      inFlight = processOne({ workerId: activeWorkerId }).then(() => void 0);
+      await inFlight;
     } finally {
-      currentRunPromise = null;
+      inFlight = null;
     }
     if (running) {
-      pollingTimeout = setTimeout(() => poll(), config.pollingInterval);
-    } else if (stopResolver) {
+      pollingTimeout = setTimeout(() => {
+        void poll();
+      }, config.pollingIntervalMs);
+      return;
+    }
+    if (stopResolver) {
       stopResolver();
       stopResolver = null;
     }
@@ -930,12 +1098,13 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
     get isRunning() {
       return running;
     },
-    start() {
+    start(options) {
       if (running) {
         return;
       }
+      activeWorkerId = options?.workerId;
       running = true;
-      poll();
+      void poll();
     },
     async stop() {
       if (!running) {
@@ -946,11 +1115,7 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
         clearTimeout(pollingTimeout);
         pollingTimeout = null;
       }
-      if (heartbeatInterval) {
-        clearInterval(heartbeatInterval);
-        heartbeatInterval = null;
-      }
-      if (currentRunPromise) {
+      if (inFlight) {
         return new Promise((resolve) => {
           stopResolver = resolve;
         });
@@ -961,12 +1126,249 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
 
 // src/durably.ts
 var DEFAULTS = {
-  pollingInterval: 1e3,
-  heartbeatInterval: 5e3,
-  staleThreshold: 3e4
+  pollingIntervalMs: 1e3,
+  leaseRenewIntervalMs: 5e3,
+  leaseMs: 3e4,
+  preserveSteps: false
 };
+function parseDuration(value) {
+  const match = value.match(/^(\d+)(d|h|m)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid duration format: "${value}". Use e.g. '30d', '24h', '60m'`
+    );
+  }
+  const num = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers = {
+    d: 864e5,
+    h: 36e5,
+    m: 6e4
+  };
+  return num * multipliers[unit];
+}
+var PURGE_INTERVAL_MS = 6e4;
+var ulid2 = monotonicFactory2();
+var BROWSER_SINGLETON_REGISTRY_KEY = "__durablyBrowserSingletonRegistry";
+var BROWSER_LOCAL_DIALECT_KEY = "__durablyBrowserLocalKey";
+function defaultWorkerId() {
+  return `worker_${ulid2()}`;
+}
+function detectBackend(dialect) {
+  return dialect.constructor.name === "PostgresDialect" ? "postgres" : "generic";
+}
+function isBrowserLikeEnvironment() {
+  return typeof globalThis.window !== "undefined" || typeof globalThis.document !== "undefined";
+}
+function getBrowserSingletonKey(dialect, explicitKey) {
+  if (!isBrowserLikeEnvironment()) {
+    return null;
+  }
+  if (explicitKey) {
+    return explicitKey;
+  }
+  const taggedDialect = dialect;
+  const taggedKey = taggedDialect[BROWSER_LOCAL_DIALECT_KEY];
+  return typeof taggedKey === "string" ? taggedKey : null;
+}
+function registerBrowserSingletonWarning(singletonKey) {
+  const globalRegistry = globalThis;
+  const registry = globalRegistry[BROWSER_SINGLETON_REGISTRY_KEY] ?? /* @__PURE__ */ new Map();
+  globalRegistry[BROWSER_SINGLETON_REGISTRY_KEY] = registry;
+  const instanceId = ulid2();
+  const instances = registry.get(singletonKey) ?? /* @__PURE__ */ new Set();
+  const hadExistingInstance = instances.size > 0;
+  instances.add(instanceId);
+  registry.set(singletonKey, instances);
+  if (hadExistingInstance && (typeof process === "undefined" || process.env.NODE_ENV !== "production")) {
+    console.warn(
+      `[durably] Multiple runtimes were created for browser-local store "${singletonKey}" in one tab. Prefer a single shared instance per tab.`
+    );
+  }
+  let released = false;
+  return () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    const activeInstances = registry.get(singletonKey);
+    if (!activeInstances) {
+      return;
+    }
+    activeInstances.delete(instanceId);
+    if (activeInstances.size === 0) {
+      registry.delete(singletonKey);
+    }
+  };
+}
 function createDurablyInstance(state, jobs) {
-  const { db, storage, eventEmitter, jobRegistry, worker } = state;
+  const {
+    db,
+    storage,
+    eventEmitter,
+    jobRegistry,
+    worker,
+    releaseBrowserSingleton
+  } = state;
+  async function getRunOrThrow(runId) {
+    const run = await storage.getRun(runId);
+    if (!run) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+    return run;
+  }
+  async function executeRun(run, workerId) {
+    const job = jobRegistry.get(run.jobName);
+    if (!job) {
+      await storage.failRun(
+        run.id,
+        run.leaseGeneration,
+        `Unknown job: ${run.jobName}`,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      return;
+    }
+    const { step, abortLeaseOwnership, dispose } = createStepContext(
+      run,
+      run.jobName,
+      run.leaseGeneration,
+      storage,
+      eventEmitter
+    );
+    let leaseDeadlineTimer = null;
+    const scheduleLeaseDeadline = (leaseExpiresAt) => {
+      if (leaseDeadlineTimer) {
+        clearTimeout(leaseDeadlineTimer);
+        leaseDeadlineTimer = null;
+      }
+      if (!leaseExpiresAt) {
+        return;
+      }
+      const delay = Math.max(0, Date.parse(leaseExpiresAt) - Date.now());
+      leaseDeadlineTimer = setTimeout(() => {
+        abortLeaseOwnership();
+      }, delay);
+    };
+    scheduleLeaseDeadline(run.leaseExpiresAt);
+    const leaseTimer = setInterval(() => {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      storage.renewLease(run.id, run.leaseGeneration, now, state.leaseMs).then((renewed) => {
+        if (!renewed) {
+          abortLeaseOwnership();
+          eventEmitter.emit({
+            type: "worker:error",
+            error: `Lease renewal lost ownership for run ${run.id}`,
+            context: "lease-renewal",
+            runId: run.id
+          });
+          return;
+        }
+        const renewedLeaseExpiresAt = new Date(
+          Date.parse(now) + state.leaseMs
+        ).toISOString();
+        scheduleLeaseDeadline(renewedLeaseExpiresAt);
+        eventEmitter.emit({
+          type: "run:lease-renewed",
+          runId: run.id,
+          jobName: run.jobName,
+          leaseOwner: workerId,
+          leaseExpiresAt: renewedLeaseExpiresAt,
+          labels: run.labels
+        });
+      }).catch((error) => {
+        eventEmitter.emit({
+          type: "worker:error",
+          error: getErrorMessage(error),
+          context: "lease-renewal",
+          runId: run.id
+        });
+      });
+    }, state.leaseRenewIntervalMs);
+    const started = Date.now();
+    let reachedTerminalState = false;
+    try {
+      eventEmitter.emit({
+        type: "run:leased",
+        runId: run.id,
+        jobName: run.jobName,
+        input: run.input,
+        leaseOwner: workerId,
+        leaseExpiresAt: run.leaseExpiresAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        labels: run.labels
+      });
+      const output = await job.fn(step, run.input);
+      if (job.outputSchema) {
+        const parseResult = job.outputSchema.safeParse(output);
+        if (!parseResult.success) {
+          throw new Error(`Invalid output: ${parseResult.error.message}`);
+        }
+      }
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const completed = await storage.completeRun(
+        run.id,
+        run.leaseGeneration,
+        output,
+        completedAt
+      );
+      if (completed) {
+        reachedTerminalState = true;
+        eventEmitter.emit({
+          type: "run:complete",
+          runId: run.id,
+          jobName: run.jobName,
+          output,
+          duration: Date.now() - started,
+          labels: run.labels
+        });
+      } else {
+        eventEmitter.emit({
+          type: "worker:error",
+          error: `Lease lost before completing run ${run.id}`,
+          context: "run-completion"
+        });
+      }
+    } catch (error) {
+      if (error instanceof LeaseLostError || error instanceof CancelledError) {
+        return;
+      }
+      const errorMessage = getErrorMessage(error);
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const failed = await storage.failRun(
+        run.id,
+        run.leaseGeneration,
+        errorMessage,
+        completedAt
+      );
+      if (failed) {
+        reachedTerminalState = true;
+        const steps = await storage.getSteps(run.id);
+        const failedStep = steps.find((entry) => entry.status === "failed");
+        eventEmitter.emit({
+          type: "run:fail",
+          runId: run.id,
+          jobName: run.jobName,
+          error: errorMessage,
+          failedStepName: failedStep?.name ?? "unknown",
+          labels: run.labels
+        });
+      } else {
+        eventEmitter.emit({
+          type: "worker:error",
+          error: `Lease lost before recording failure for run ${run.id}`,
+          context: "run-failure"
+        });
+      }
+    } finally {
+      clearInterval(leaseTimer);
+      if (leaseDeadlineTimer) {
+        clearTimeout(leaseDeadlineTimer);
+      }
+      dispose();
+      if (!state.preserveSteps && reachedTerminalState) {
+        await storage.deleteSteps(run.id);
+      }
+    }
+  }
   const durably = {
     db,
     storage,
@@ -975,7 +1377,10 @@ function createDurablyInstance(state, jobs) {
     emit: eventEmitter.emit,
     onError: eventEmitter.onError,
     start: worker.start,
-    stop: worker.stop,
+    async stop() {
+      releaseBrowserSingleton();
+      await worker.stop();
+    },
     // biome-ignore lint/suspicious/noExplicitAny: flexible type constraint for job definitions
     register(jobDefs) {
       const newHandles = {};
@@ -996,8 +1401,8 @@ function createDurablyInstance(state, jobs) {
         mergedJobs
       );
     },
-    getRun: storage.getRun,
-    getRuns: storage.getRuns,
+    getRun: storage.getRun.bind(storage),
+    getRuns: storage.getRuns.bind(storage),
     use(plugin) {
       plugin.install(durably);
     },
@@ -1011,14 +1416,18 @@ function createDurablyInstance(state, jobs) {
     subscribe(runId) {
       let closed = false;
       let cleanup = null;
-      const closeEvents = /* @__PURE__ */ new Set(["run:complete", "run:delete"]);
+      const closeEvents = /* @__PURE__ */ new Set([
+        "run:complete",
+        "run:fail",
+        "run:cancel",
+        "run:delete"
+      ]);
       const subscribedEvents = [
-        "run:start",
+        "run:leased",
         "run:complete",
         "run:fail",
         "run:cancel",
         "run:delete",
-        "run:retry",
         "run:progress",
         "step:start",
         "step:complete",
@@ -1041,6 +1450,64 @@ function createDurablyInstance(state, jobs) {
           cleanup = () => {
             for (const unsub of unsubscribes) unsub();
           };
+          const closeStream = () => {
+            closed = true;
+            cleanup?.();
+            controller.close();
+          };
+          storage.getRun(runId).then((run) => {
+            if (closed || !run) return;
+            const base = {
+              runId,
+              jobName: run.jobName,
+              labels: run.labels,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              sequence: 0
+            };
+            if (run.status === "leased") {
+              controller.enqueue({
+                ...base,
+                type: "run:leased",
+                input: run.input,
+                leaseOwner: run.leaseOwner ?? "",
+                leaseExpiresAt: run.leaseExpiresAt ?? ""
+              });
+              if (run.progress != null) {
+                controller.enqueue({
+                  ...base,
+                  type: "run:progress",
+                  progress: run.progress
+                });
+              }
+            } else if (run.status === "completed") {
+              controller.enqueue({
+                ...base,
+                type: "run:complete",
+                output: run.output,
+                duration: 0
+              });
+              closeStream();
+            } else if (run.status === "failed") {
+              controller.enqueue({
+                ...base,
+                type: "run:fail",
+                error: run.error ?? "Unknown error",
+                failedStepName: ""
+              });
+              closeStream();
+            } else if (run.status === "cancelled") {
+              controller.enqueue({
+                ...base,
+                type: "run:cancel"
+              });
+              closeStream();
+            }
+          }).catch((error) => {
+            if (closed) return;
+            closed = true;
+            cleanup?.();
+            controller.error(error);
+          });
         },
         cancel: () => {
           if (!closed) {
@@ -1050,36 +1517,40 @@ function createDurablyInstance(state, jobs) {
         }
       });
     },
-    async retry(runId) {
-      const run = await storage.getRun(runId);
-      if (!run) {
-        throw new Error(`Run not found: ${runId}`);
-      }
-      if (run.status === "completed") {
-        throw new Error(`Cannot retry completed run: ${runId}`);
-      }
+    async retrigger(runId) {
+      const run = await getRunOrThrow(runId);
       if (run.status === "pending") {
-        throw new Error(`Cannot retry pending run: ${runId}`);
+        throw new Error(`Cannot retrigger pending run: ${runId}`);
       }
-      if (run.status === "running") {
-        throw new Error(`Cannot retry running run: ${runId}`);
+      if (run.status === "leased") {
+        throw new Error(`Cannot retrigger leased run: ${runId}`);
       }
-      await storage.updateRun(runId, {
-        status: "pending",
-        error: null
+      const job = jobRegistry.get(run.jobName);
+      if (!job) {
+        throw new Error(`Unknown job: ${run.jobName}`);
+      }
+      const validatedInput = validateJobInputOrThrow(
+        job.inputSchema,
+        run.input,
+        `Cannot retrigger run ${runId}`
+      );
+      const nextRun = await storage.enqueue({
+        jobName: run.jobName,
+        input: validatedInput,
+        concurrencyKey: run.concurrencyKey ?? void 0,
+        labels: run.labels
       });
       eventEmitter.emit({
-        type: "run:retry",
-        runId,
+        type: "run:trigger",
+        runId: nextRun.id,
         jobName: run.jobName,
+        input: validatedInput,
         labels: run.labels
       });
+      return nextRun;
     },
     async cancel(runId) {
-      const run = await storage.getRun(runId);
-      if (!run) {
-        throw new Error(`Run not found: ${runId}`);
-      }
+      const run = await getRunOrThrow(runId);
       if (run.status === "completed") {
         throw new Error(`Cannot cancel completed run: ${runId}`);
       }
@@ -1089,9 +1560,17 @@ function createDurablyInstance(state, jobs) {
       if (run.status === "cancelled") {
         throw new Error(`Cannot cancel already cancelled run: ${runId}`);
       }
-      await storage.updateRun(runId, {
-        status: "cancelled"
-      });
+      const wasPending = run.status === "pending";
+      const cancelled = await storage.cancelRun(runId, (/* @__PURE__ */ new Date()).toISOString());
+      if (!cancelled) {
+        const current = await getRunOrThrow(runId);
+        throw new Error(
+          `Cannot cancel run ${runId}: status changed to ${current.status}`
+        );
+      }
+      if (wasPending && !state.preserveSteps) {
+        await storage.deleteSteps(runId);
+      }
       eventEmitter.emit({
         type: "run:cancel",
         runId,
@@ -1100,15 +1579,12 @@ function createDurablyInstance(state, jobs) {
       });
     },
     async deleteRun(runId) {
-      const run = await storage.getRun(runId);
-      if (!run) {
-        throw new Error(`Run not found: ${runId}`);
-      }
+      const run = await getRunOrThrow(runId);
       if (run.status === "pending") {
         throw new Error(`Cannot delete pending run: ${runId}`);
       }
-      if (run.status === "running") {
-        throw new Error(`Cannot delete running run: ${runId}`);
+      if (run.status === "leased") {
+        throw new Error(`Cannot delete leased run: ${runId}`);
       }
       await storage.deleteRun(runId);
       eventEmitter.emit({
@@ -1118,6 +1594,48 @@ function createDurablyInstance(state, jobs) {
         labels: run.labels
       });
     },
+    async purgeRuns(options) {
+      return storage.purgeRuns({
+        olderThan: options.olderThan.toISOString(),
+        limit: options.limit
+      });
+    },
+    async processOne(options) {
+      const workerId = options?.workerId ?? defaultWorkerId();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await storage.releaseExpiredLeases(now);
+      const run = await storage.claimNext(workerId, now, state.leaseMs);
+      if (!run) {
+        if (state.retainRunsMs !== null && Date.now() - state.lastPurgeAt >= PURGE_INTERVAL_MS) {
+          const purgeNow = Date.now();
+          state.lastPurgeAt = purgeNow;
+          const cutoff = new Date(purgeNow - state.retainRunsMs).toISOString();
+          storage.purgeRuns({ olderThan: cutoff, limit: 100 }).catch((error) => {
+            eventEmitter.emit({
+              type: "worker:error",
+              error: getErrorMessage(error),
+              context: "auto-purge"
+            });
+          });
+        }
+        return false;
+      }
+      await executeRun(run, workerId);
+      return true;
+    },
+    async processUntilIdle(options) {
+      const workerId = options?.workerId ?? defaultWorkerId();
+      const maxRuns = options?.maxRuns ?? Number.POSITIVE_INFINITY;
+      let processed = 0;
+      while (processed < maxRuns) {
+        const didProcess = await this.processOne({ workerId });
+        if (!didProcess) {
+          break;
+        }
+        processed++;
+      }
+      return processed;
+    },
     async migrate() {
       if (state.migrated) {
         return;
@@ -1141,15 +1659,38 @@ function createDurablyInstance(state, jobs) {
 }
 function createDurably(options) {
   const config = {
-    pollingInterval: options.pollingInterval ?? DEFAULTS.pollingInterval,
-    heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
-    staleThreshold: options.staleThreshold ?? DEFAULTS.staleThreshold
+    pollingIntervalMs: options.pollingIntervalMs ?? DEFAULTS.pollingIntervalMs,
+    leaseRenewIntervalMs: options.leaseRenewIntervalMs ?? DEFAULTS.leaseRenewIntervalMs,
+    leaseMs: options.leaseMs ?? DEFAULTS.leaseMs,
+    preserveSteps: options.preserveSteps ?? DEFAULTS.preserveSteps,
+    retainRunsMs: options.retainRuns ? parseDuration(options.retainRuns) : null
   };
   const db = new Kysely({ dialect: options.dialect });
-  const storage = createKyselyStorage(db);
+  const singletonKey = getBrowserSingletonKey(
+    options.dialect,
+    options.singletonKey
+  );
+  const releaseBrowserSingleton = singletonKey !== null ? registerBrowserSingletonWarning(singletonKey) : () => {
+  };
+  const backend = detectBackend(options.dialect);
+  const storage = createKyselyStore(db, backend);
+  const originalDestroy = db.destroy.bind(db);
+  db.destroy = (async () => {
+    releaseBrowserSingleton();
+    return originalDestroy();
+  });
   const eventEmitter = createEventEmitter();
   const jobRegistry = createJobRegistry();
-  const worker = createWorker(config, storage, eventEmitter, jobRegistry);
+  let processOneImpl = null;
+  const worker = createWorker(
+    { pollingIntervalMs: config.pollingIntervalMs },
+    (runtimeOptions) => {
+      if (!processOneImpl) {
+        throw new Error("Durably runtime is not initialized");
+      }
+      return processOneImpl(runtimeOptions);
+    }
+  );
   const state = {
     db,
     storage,
@@ -1157,13 +1698,20 @@ function createDurably(options) {
     jobRegistry,
     worker,
     labelsSchema: options.labels,
+    preserveSteps: config.preserveSteps,
     migrating: null,
-    migrated: false
+    migrated: false,
+    leaseMs: config.leaseMs,
+    leaseRenewIntervalMs: config.leaseRenewIntervalMs,
+    retainRunsMs: config.retainRunsMs,
+    lastPurgeAt: 0,
+    releaseBrowserSingleton
   };
   const instance = createDurablyInstance(
     state,
     {}
   );
+  processOneImpl = instance.processOne;
   if (options.jobs) {
     return instance.register(options.jobs);
   }
@@ -1408,7 +1956,7 @@ function createThrottledSSEController(inner, throttleMs) {
 // src/server.ts
 var VALID_STATUSES = [
   "pending",
-  "running",
+  "leased",
   "completed",
   "failed",
   "cancelled"
@@ -1564,12 +2112,12 @@ function createDurablyHandler(durably, options) {
       return jsonResponse(steps);
     });
   }
-  async function handleRetry(url, ctx) {
+  async function handleRetrigger(url, ctx) {
     return withErrorHandling(async () => {
-      const result = await requireRunAccess(url, ctx, "retry");
+      const result = await requireRunAccess(url, ctx, "retrigger");
       if (result instanceof Response) return result;
-      await durably.retry(result.runId);
-      return successResponse();
+      const run = await durably.retrigger(result.runId);
+      return jsonResponse({ success: true, runId: run.id });
     });
   }
   async function handleCancel(url, ctx) {
@@ -1638,10 +2186,10 @@ function createDurablyHandler(durably, options) {
               });
             }
           }),
-          durably.on("run:start", (event) => {
+          durably.on("run:leased", (event) => {
             if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
-                type: "run:start",
+                type: "run:leased",
                 runId: event.runId,
                 jobName: event.jobName,
                 labels: event.labels
@@ -1688,16 +2236,6 @@ function createDurablyHandler(durably, options) {
               });
             }
           }),
-          durably.on("run:retry", (event) => {
-            if (matchesFilter(event.jobName, event.labels)) {
-              ctrl.enqueue({
-                type: "run:retry",
-                runId: event.runId,
-                jobName: event.jobName,
-                labels: event.labels
-              });
-            }
-          }),
           durably.on("run:progress", (event) => {
             if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
@@ -1801,7 +2339,7 @@ function createDurablyHandler(durably, options) {
         }
         if (method === "POST") {
           if (path === "/trigger") return await handleTrigger(request, ctx);
-          if (path === "/retry") return await handleRetry(url, ctx);
+          if (path === "/retrigger") return await handleRetrigger(url, ctx);
           if (path === "/cancel") return await handleCancel(url, ctx);
         }
         if (method === "DELETE") {
@@ -1817,8 +2355,10 @@ function createDurablyHandler(durably, options) {
 }
 export {
   CancelledError,
+  LeaseLostError,
   createDurably,
   createDurablyHandler,
+  createKyselyStore,
   defineJob,
   toClientRun,
   withLogPersistence