@coji/durably 0.12.0 → 0.14.0

package/dist/index.js

@@ -1,9 +1,254 @@
 import {
   withLogPersistence
-} from "./chunk-UCUP6NMJ.js";
+} from "./chunk-L42OCQEV.js";
 
 // 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";
+  }
+};
+var DurablyError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "DurablyError";
+    this.statusCode = statusCode;
+  }
+};
+var NotFoundError = class extends DurablyError {
+  constructor(message) {
+    super(message, 404);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends DurablyError {
+  constructor(message) {
+    super(message, 400);
+    this.name = "ValidationError";
+  }
+};
+var ConflictError = class extends DurablyError {
+  constructor(message) {
+    super(message, 409);
+    this.name = "ConflictError";
+  }
+};
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(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);
+  }
+  async function throwForRefusedStep(stepName, stepIndex2) {
+    const latestRun = await storage.getRun(run.id);
+    if (latestRun?.status === "cancelled") {
+      eventEmitter.emit({
+        type: "step:cancel",
+        runId: run.id,
+        jobName,
+        stepName,
+        stepIndex: stepIndex2,
+        labels: run.labels
+      });
+      throw new CancelledError(run.id);
+    }
+    abortForLeaseLoss();
+    throw new LeaseLostError(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) {
+          await throwForRefusedStep(name, stepIndex);
+        }
+        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) {
+          await throwForRefusedStep(name, stepIndex);
+        }
+        eventEmitter.emit({
+          type: "step:fail",
+          error: errorMessage,
+          runId: run.id,
+          jobName,
+          stepName: name,
+          stepIndex,
+          labels: run.labels
+        });
+        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() {
@@ -35,16 +280,16 @@ function createEventEmitter() {
       if (!typeListeners) {
         return;
       }
+      const reportError = (error) => errorHandler?.(toError(error), fullEvent);
       for (const listener of typeListeners) {
         try {
-          listener(fullEvent);
-        } catch (error) {
-          if (errorHandler) {
-            errorHandler(
-              error instanceof Error ? error : new Error(String(error)),
-              fullEvent
-            );
+          const result = listener(fullEvent);
+          if (result != null && typeof result.then === "function") {
+            ;
+            result.catch(reportError);
           }
+        } catch (error) {
+          reportError(error);
         }
       }
     }
@@ -59,7 +304,9 @@ function validateJobInputOrThrow(schema, input, context) {
   const result = schema.safeParse(input);
   if (!result.success) {
     const prefix = context ? `${context}: ` : "";
-    throw new Error(`${prefix}Invalid input: ${prettifyError(result.error)}`);
+    throw new ValidationError(
+      `${prefix}Invalid input: ${prettifyError(result.error)}`
+    );
   }
   return result.data;
 }
@@ -96,7 +343,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,
@@ -183,7 +430,7 @@ function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema)
         }).catch((error) => {
           if (resolved) return;
           cleanup();
-          reject(error instanceof Error ? error : new Error(String(error)));
+          reject(toError(error));
         });
         if (options?.timeout !== void 0) {
           timeoutId = setTimeout(() => {
@@ -226,7 +473,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 +521,7 @@ function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema)
 }
 
 // src/migrations.ts
+import { sql } from "kysely";
 var migrations = [
   {
     version: 1,
@@ -282,12 +530,30 @@ 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(
+        "completed_step_count",
+        "integer",
+        (col) => col.notNull().defaultTo(0)
+      ).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,30 +584,13 @@ async function runMigrations(db) {
 }
 
 // src/storage.ts
-import { sql } from "kysely";
+import { sql as sql4 } from "kysely";
 import { monotonicFactory } from "ulidx";
-var ulid = monotonicFactory();
-function toClientRun(run) {
-  const {
-    idempotencyKey,
-    concurrencyKey,
-    heartbeatAt,
-    updatedAt,
-    ...clientRun
-  } = run;
-  return clientRun;
-}
-var LABEL_KEY_PATTERN = /^[a-zA-Z0-9\-_./]+$/;
-function validateLabels(labels) {
-  if (!labels) return;
-  for (const key of Object.keys(labels)) {
-    if (!LABEL_KEY_PATTERN.test(key)) {
-      throw new Error(
-        `Invalid label key "${key}": must contain only alphanumeric characters, dashes, underscores, dots, and slashes`
-      );
-    }
-  }
-}
+
+// src/claim-postgres.ts
+import { sql as sql2 } from "kysely";
+
+// src/transformers.ts
 function rowToRun(row) {
   return {
     id: row.id,
@@ -351,12 +600,14 @@ function rowToRun(row) {
     idempotencyKey: row.idempotency_key,
     concurrencyKey: row.concurrency_key,
     currentStepIndex: row.current_step_index,
-    stepCount: Number(row.step_count ?? 0),
+    completedStepCount: row.completed_step_count,
     progress: row.progress ? JSON.parse(row.progress) : null,
     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 +638,166 @@ function rowToLog(row) {
     createdAt: row.created_at
   };
 }
-function createKyselyStorage(db) {
-  return {
-    async createRun(input) {
+var LABEL_KEY_PATTERN = /^[a-zA-Z0-9\-_./]+$/;
+function validateLabels(labels) {
+  if (!labels) return;
+  for (const key of Object.keys(labels)) {
+    if (!LABEL_KEY_PATTERN.test(key)) {
+      throw new Error(
+        `Invalid label key "${key}": must contain only alphanumeric characters, dashes, underscores, dots, and slashes`
+      );
+    }
+  }
+}
+
+// src/claim-postgres.ts
+async function claimNextPostgres(db, workerId, now, leaseExpiresAt, activeLeaseGuard) {
+  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 row = result.rows[0];
+      if (!row) return null;
+      return rowToRun(row);
+    }
+  });
+}
+
+// src/claim-sqlite.ts
+import { sql as sql3 } from "kysely";
+async function claimNextSqlite(db, workerId, now, leaseExpiresAt, activeLeaseGuard) {
+  const 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: "leased",
+    lease_owner: workerId,
+    lease_expires_at: leaseExpiresAt,
+    lease_generation: sql3`lease_generation + 1`,
+    started_at: sql3`COALESCE(started_at, ${now})`,
+    updated_at: now
+  }).where("id", "=", (eb) => eb.selectFrom(subquery.as("sub")).select("id")).returningAll().executeTakeFirst();
+  if (!row) return null;
+  return rowToRun(row);
+}
+
+// src/storage.ts
+var ulid = monotonicFactory();
+var TERMINAL_STATUSES = ["completed", "failed", "cancelled"];
+function toClientRun(run) {
+  const {
+    idempotencyKey,
+    concurrencyKey,
+    leaseOwner,
+    leaseExpiresAt,
+    leaseGeneration,
+    updatedAt,
+    ...clientRun
+  } = run;
+  return clientRun;
+}
+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();
@@ -407,20 +815,26 @@ function createKyselyStorage(db) {
         idempotency_key: input.idempotencyKey ?? null,
         concurrency_key: input.concurrencyKey ?? null,
         current_step_index: 0,
+        completed_step_count: 0,
         progress: null,
         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 +844,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 +854,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,
@@ -447,11 +867,14 @@ function createKyselyStorage(db) {
             idempotency_key: input.idempotencyKey ?? null,
             concurrency_key: input.concurrencyKey ?? null,
             current_step_index: 0,
+            completed_step_count: 0,
             progress: null,
             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,55 +884,29 @@ 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")
-      ).where("durably_runs.id", "=", runId).groupBy("durably_runs.id").executeTakeFirst();
+      const row = await db.selectFrom("durably_runs").selectAll().where("id", "=", runId).executeTakeFirst();
       return row ? rowToRun(row) : null;
     },
     async getRuns(filter) {
-      let query = 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")
-      ).groupBy("durably_runs.id");
+      let query = db.selectFrom("durably_runs").selectAll();
       if (filter?.status) {
-        query = query.where("durably_runs.status", "=", filter.status);
+        query = query.where("status", "=", filter.status);
       }
       if (filter?.jobName) {
         if (Array.isArray(filter.jobName)) {
           if (filter.jobName.length > 0) {
-            query = query.where("durably_runs.job_name", "in", filter.jobName);
+            query = query.where("job_name", "in", filter.jobName);
           }
         } else {
-          query = query.where("durably_runs.job_name", "=", filter.jobName);
+          query = query.where("job_name", "=", filter.jobName);
         }
       }
       if (filter?.labels) {
@@ -518,13 +915,13 @@ function createKyselyStorage(db) {
         for (const [key, value] of Object.entries(labels)) {
           if (value === void 0) continue;
           query = query.where(
-            sql`json_extract(durably_runs.labels, ${`$."${key}"`})`,
-            "=",
-            value
+            (eb) => eb.exists(
+              eb.selectFrom("durably_run_labels").select(sql4.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)
+            )
           );
         }
       }
-      query = query.orderBy("durably_runs.created_at", "desc");
+      query = query.orderBy("created_at", "desc");
       if (filter?.limit !== void 0) {
         query = query.limit(filter.limit);
       }
@@ -537,400 +934,226 @@ 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 row = await db.updateTable("durably_runs").set({
-        status: "running",
-        heartbeat_at: now,
-        started_at: sql`COALESCE(started_at, ${now})`,
+      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",
-        "=",
-        (eb) => eb.selectFrom(subquery.as("sub")).select("id")
-      ).returningAll().executeTakeFirst();
-      if (!row) return null;
-      return rowToRun({ ...row, step_count: 0 });
+      }).where("id", "=", runId).execute();
     },
-    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 deleteRun(runId) {
+      await db.transaction().execute(async (trx) => {
+        await cascadeDeleteRuns(trx, [runId]);
+      });
     },
-    async deleteSteps(runId) {
-      await db.deleteFrom("durably_steps").where("run_id", "=", runId).execute();
+    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 getSteps(runId) {
-      const rows = await db.selectFrom("durably_steps").selectAll().where("run_id", "=", runId).orderBy("index", "asc").execute();
-      return rows.map(rowToStep);
+    async claimNext(workerId, now, leaseMs) {
+      const leaseExpiresAt = new Date(Date.parse(now) + leaseMs).toISOString();
+      const activeLeaseGuard = sql4`
+        (
+          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}
+          )
+        )
+      `;
+      return backend === "postgres" ? claimNextPostgres(db, workerId, now, leaseExpiresAt, activeLeaseGuard) : claimNextSqlite(db, workerId, now, leaseExpiresAt, activeLeaseGuard);
     },
-    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 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 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 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 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 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
+    async completeRun(runId, leaseGeneration, output, completedAt) {
+      return terminateRun(runId, leaseGeneration, completedAt, {
+        status: "completed",
+        output: JSON.stringify(output),
+        error: null
       });
-      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);
-        }
-        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
+    async failRun(runId, leaseGeneration, error, completedAt) {
+      return terminateRun(runId, leaseGeneration, completedAt, {
+        status: "failed",
+        error
       });
     },
-    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 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 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 sql4`
+          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 status = 'leased' 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,
+            completed_step_count: sql4`completed_step_count + 1`,
+            updated_at: completedAt
+          }).where("id", "=", runId).where("status", "=", "leased").where("lease_generation", "=", leaseGeneration).execute();
+        }
+        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
+        };
+      });
+    },
+    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("status", "=", "leased").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 };
+  if (backend !== "postgres") {
+    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, onIdle) {
   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") {
+  let activeWorkerId;
+  async function poll() {
+    if (!running) {
       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 {
-      if (config.cleanupSteps) {
+    const cycle = (async () => {
+      const didProcess = await processOne({ workerId: activeWorkerId });
+      if (!didProcess && onIdle && running) {
         try {
-          await storage.deleteSteps(run.id);
+          await onIdle();
         } catch {
         }
       }
-      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;
-  }
-  async function poll() {
-    if (!running) {
-      return;
-    }
-    const doWork = async () => {
-      await recoverStaleRuns();
-      await processNextRun();
-    };
+    })();
+    inFlight = cycle;
     try {
-      currentRunPromise = doWork();
-      await currentRunPromise;
+      await cycle;
     } 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;
     }
@@ -939,12 +1162,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) {
@@ -955,11 +1179,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;
         });
@@ -970,20 +1190,249 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
 
 // src/durably.ts
 var DEFAULTS = {
-  pollingInterval: 1e3,
-  heartbeatInterval: 5e3,
-  staleThreshold: 3e4,
-  cleanupSteps: true
+  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}`);
+      throw new NotFoundError(`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,
@@ -992,7 +1441,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 = {};
@@ -1013,8 +1465,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);
     },
@@ -1028,9 +1480,14 @@ 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",
@@ -1057,6 +1514,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) {
@@ -1069,17 +1584,23 @@ function createDurablyInstance(state, jobs) {
     async retrigger(runId) {
       const run = await getRunOrThrow(runId);
       if (run.status === "pending") {
-        throw new Error(`Cannot retrigger pending run: ${runId}`);
+        throw new ConflictError(`Cannot retrigger pending run: ${runId}`);
       }
-      if (run.status === "running") {
-        throw new Error(`Cannot retrigger running run: ${runId}`);
+      if (run.status === "leased") {
+        throw new ConflictError(`Cannot retrigger leased run: ${runId}`);
       }
-      if (!jobRegistry.get(run.jobName)) {
-        throw new Error(`Unknown job: ${run.jobName}`);
+      const job = jobRegistry.get(run.jobName);
+      if (!job) {
+        throw new NotFoundError(`Unknown job: ${run.jobName}`);
       }
-      const nextRun = await storage.createRun({
+      const validatedInput = validateJobInputOrThrow(
+        job.inputSchema,
+        run.input,
+        `Cannot retrigger run ${runId}`
+      );
+      const nextRun = await storage.enqueue({
         jobName: run.jobName,
-        input: run.input,
+        input: validatedInput,
         concurrencyKey: run.concurrencyKey ?? void 0,
         labels: run.labels
       });
@@ -1087,7 +1608,7 @@ function createDurablyInstance(state, jobs) {
         type: "run:trigger",
         runId: nextRun.id,
         jobName: run.jobName,
-        input: run.input,
+        input: validatedInput,
         labels: run.labels
       });
       return nextRun;
@@ -1095,20 +1616,23 @@ function createDurablyInstance(state, jobs) {
     async cancel(runId) {
       const run = await getRunOrThrow(runId);
       if (run.status === "completed") {
-        throw new Error(`Cannot cancel completed run: ${runId}`);
+        throw new ConflictError(`Cannot cancel completed run: ${runId}`);
       }
       if (run.status === "failed") {
-        throw new Error(`Cannot cancel failed run: ${runId}`);
+        throw new ConflictError(`Cannot cancel failed run: ${runId}`);
       }
       if (run.status === "cancelled") {
-        throw new Error(`Cannot cancel already cancelled run: ${runId}`);
+        throw new ConflictError(`Cannot cancel already cancelled run: ${runId}`);
       }
       const wasPending = run.status === "pending";
-      await storage.updateRun(runId, {
-        status: "cancelled",
-        completedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      if (wasPending && state.cleanupSteps) {
+      const cancelled = await storage.cancelRun(runId, (/* @__PURE__ */ new Date()).toISOString());
+      if (!cancelled) {
+        const current = await getRunOrThrow(runId);
+        throw new ConflictError(
+          `Cannot cancel run ${runId}: status changed to ${current.status}`
+        );
+      }
+      if (wasPending && !state.preserveSteps) {
         await storage.deleteSteps(runId);
       }
       eventEmitter.emit({
@@ -1121,10 +1645,10 @@ function createDurablyInstance(state, jobs) {
     async deleteRun(runId) {
       const run = await getRunOrThrow(runId);
       if (run.status === "pending") {
-        throw new Error(`Cannot delete pending run: ${runId}`);
+        throw new ConflictError(`Cannot delete pending run: ${runId}`);
       }
-      if (run.status === "running") {
-        throw new Error(`Cannot delete running run: ${runId}`);
+      if (run.status === "leased") {
+        throw new ConflictError(`Cannot delete leased run: ${runId}`);
       }
       await storage.deleteRun(runId);
       eventEmitter.emit({
@@ -1134,6 +1658,40 @@ 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();
+      const run = await storage.claimNext(workerId, now, state.leaseMs);
+      if (!run) {
+        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;
+      let reachedIdle = false;
+      while (processed < maxRuns) {
+        const didProcess = await this.processOne({ workerId });
+        if (!didProcess) {
+          reachedIdle = true;
+          break;
+        }
+        processed++;
+      }
+      if (reachedIdle) {
+        await state.runIdleMaintenance();
+      }
+      return processed;
+    },
     async migrate() {
       if (state.migrated) {
         return;
@@ -1157,16 +1715,60 @@ function createDurablyInstance(state, jobs) {
 }
 function createDurably(options) {
   const config = {
-    pollingInterval: options.pollingInterval ?? DEFAULTS.pollingInterval,
-    heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
-    staleThreshold: options.staleThreshold ?? DEFAULTS.staleThreshold,
-    cleanupSteps: options.cleanupSteps ?? DEFAULTS.cleanupSteps
+    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 lastPurgeAt = 0;
+  const runIdleMaintenance = async () => {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await storage.releaseExpiredLeases(now);
+      if (config.retainRunsMs !== null) {
+        const purgeNow = Date.now();
+        if (purgeNow - lastPurgeAt >= PURGE_INTERVAL_MS) {
+          lastPurgeAt = purgeNow;
+          const cutoff = new Date(purgeNow - config.retainRunsMs).toISOString();
+          await storage.purgeRuns({ olderThan: cutoff, limit: 100 });
+        }
+      }
+    } catch (error) {
+      eventEmitter.emit({
+        type: "worker:error",
+        error: getErrorMessage(error),
+        context: "idle-maintenance"
+      });
+    }
+  };
+  let processOneImpl = null;
+  const worker = createWorker(
+    { pollingIntervalMs: config.pollingIntervalMs },
+    (runtimeOptions) => {
+      if (!processOneImpl) {
+        throw new Error("Durably runtime is not initialized");
+      }
+      return processOneImpl(runtimeOptions);
+    },
+    runIdleMaintenance
+  );
   const state = {
     db,
     storage,
@@ -1174,14 +1776,20 @@ function createDurably(options) {
     jobRegistry,
     worker,
     labelsSchema: options.labels,
-    cleanupSteps: config.cleanupSteps,
+    preserveSteps: config.preserveSteps,
     migrating: null,
-    migrated: false
+    migrated: false,
+    leaseMs: config.leaseMs,
+    leaseRenewIntervalMs: config.leaseRenewIntervalMs,
+    retainRunsMs: config.retainRunsMs,
+    releaseBrowserSingleton,
+    runIdleMaintenance
   };
   const instance = createDurablyInstance(
     state,
     {}
   );
+  processOneImpl = instance.processOne;
   if (options.jobs) {
     return instance.register(options.jobs);
   }
@@ -1426,7 +2034,7 @@ function createThrottledSSEController(inner, throttleMs) {
 // src/server.ts
 var VALID_STATUSES = [
   "pending",
-  "running",
+  "leased",
   "completed",
   "failed",
   "cancelled"
@@ -1505,6 +2113,12 @@ function createDurablyHandler(durably, options) {
       return await fn();
     } catch (error) {
       if (error instanceof Response) throw error;
+      if (error instanceof DurablyError) {
+        return errorResponse(
+          error.message,
+          error.statusCode
+        );
+      }
       return errorResponse(getErrorMessage(error), 500);
     }
   }
@@ -1533,14 +2147,11 @@ function createDurablyHandler(durably, options) {
       if (auth?.onTrigger && ctx !== void 0) {
         await auth.onTrigger(ctx, body);
       }
-      const run = await job.trigger(
-        body.input ?? {},
-        {
-          idempotencyKey: body.idempotencyKey,
-          concurrencyKey: body.concurrencyKey,
-          labels: body.labels
-        }
-      );
+      const run = await job.trigger(body.input, {
+        idempotencyKey: body.idempotencyKey,
+        concurrencyKey: body.concurrencyKey,
+        labels: body.labels
+      });
       const response = { runId: run.id };
       return jsonResponse(response);
     });
@@ -1656,10 +2267,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
@@ -1825,8 +2436,14 @@ function createDurablyHandler(durably, options) {
 }
 export {
   CancelledError,
+  ConflictError,
+  DurablyError,
+  LeaseLostError,
+  NotFoundError,
+  ValidationError,
   createDurably,
   createDurablyHandler,
+  createKyselyStore,
   defineJob,
   toClientRun,
   withLogPersistence