@coji/durably 0.13.0 → 0.15.0

package/dist/index.js

@@ -1,9 +1,9 @@
 import {
   withLogPersistence
-} from "./chunk-UCUP6NMJ.js";
+} from "./chunk-L42OCQEV.js";
 
 // src/durably.ts
-import { Kysely } from "kysely";
+import { Kysely, sql as sql5 } from "kysely";
 import { monotonicFactory as monotonicFactory2 } from "ulidx";
 
 // src/errors.ts
@@ -19,197 +19,54 @@ var LeaseLostError = class extends Error {
     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);
 }
-
-// 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
-  };
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
 }
 
 // src/events.ts
+var DOMAIN_EVENT_TYPE_VALUES = [
+  "run:trigger",
+  "run:coalesced",
+  "run:complete",
+  "run:fail",
+  "run:cancel",
+  "run:delete"
+];
+var DOMAIN_EVENT_TYPES = new Set(
+  DOMAIN_EVENT_TYPE_VALUES
+);
+function isDomainEvent(event) {
+  return DOMAIN_EVENT_TYPES.has(event.type);
+}
 function createEventEmitter() {
   const listeners = /* @__PURE__ */ new Map();
   let sequence = 0;
@@ -239,16 +96,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);
         }
       }
     }
@@ -257,13 +114,16 @@ function createEventEmitter() {
 
 // src/job.ts
 import { prettifyError } from "zod";
+var DEFAULT_WAIT_POLLING_INTERVAL_MS = 1e3;
 var noop = () => {
 };
 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;
 }
@@ -281,7 +141,157 @@ function createJobRegistry() {
     }
   };
 }
-function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema) {
+function waitForRunCompletion(runId, storage, eventEmitter, options, timeoutMessagePrefix = "waitForRun") {
+  return new Promise((resolve, reject) => {
+    let timeoutId;
+    let pollIntervalId;
+    let resolved = false;
+    let pollInFlight = false;
+    const unsubscribes = [];
+    const pollingMs = options?.pollingIntervalMs ?? DEFAULT_WAIT_POLLING_INTERVAL_MS;
+    if (!Number.isFinite(pollingMs) || pollingMs <= 0) {
+      throw new ValidationError(
+        "pollingIntervalMs must be a positive finite number"
+      );
+    }
+    const cleanup = () => {
+      if (resolved) return;
+      resolved = true;
+      for (const unsub of unsubscribes) unsub();
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      if (pollIntervalId !== void 0) {
+        clearInterval(pollIntervalId);
+        pollIntervalId = void 0;
+      }
+    };
+    const settleFromStorage = (run) => {
+      if (resolved) return;
+      if (!run) {
+        cleanup();
+        reject(new NotFoundError(`Run not found: ${runId}`));
+        return;
+      }
+      if (run.status === "completed") {
+        cleanup();
+        resolve(run);
+        return;
+      }
+      if (run.status === "failed") {
+        cleanup();
+        reject(new Error(run.error || "Run failed"));
+        return;
+      }
+      if (run.status === "cancelled") {
+        cleanup();
+        reject(new CancelledError(runId));
+        return;
+      }
+    };
+    const poll = () => {
+      if (resolved || pollInFlight) return;
+      pollInFlight = true;
+      void storage.getRun(runId).then((run) => {
+        if (resolved) return;
+        settleFromStorage(run);
+      }).catch((err) => {
+        if (resolved) return;
+        cleanup();
+        reject(toError(err));
+      }).finally(() => {
+        pollInFlight = false;
+      });
+    };
+    unsubscribes.push(
+      eventEmitter.on("run:complete", (event) => {
+        if (event.runId !== runId || resolved) return;
+        cleanup();
+        storage.getRun(runId).then((run) => {
+          if (run) resolve(run);
+          else reject(new NotFoundError(`Run not found: ${runId}`));
+        }).catch((err) => reject(toError(err)));
+      })
+    );
+    unsubscribes.push(
+      eventEmitter.on("run:fail", (event) => {
+        if (event.runId !== runId || resolved) return;
+        cleanup();
+        reject(new Error(event.error));
+      })
+    );
+    unsubscribes.push(
+      eventEmitter.on("run:cancel", (event) => {
+        if (event.runId !== runId || resolved) return;
+        cleanup();
+        reject(new CancelledError(runId));
+      })
+    );
+    if (options?.onProgress) {
+      const onProgress = options.onProgress;
+      unsubscribes.push(
+        eventEmitter.on("run:progress", (event) => {
+          if (event.runId !== runId || resolved) return;
+          void Promise.resolve(onProgress(event.progress)).catch(noop);
+        })
+      );
+    }
+    if (options?.onLog) {
+      const onLog = options.onLog;
+      unsubscribes.push(
+        eventEmitter.on("log:write", (event) => {
+          if (event.runId !== runId || resolved) return;
+          const { level, message, data, stepName } = event;
+          void Promise.resolve(onLog({ level, message, data, stepName })).catch(
+            noop
+          );
+        })
+      );
+    }
+    storage.getRun(runId).then((currentRun) => {
+      if (resolved) return;
+      if (!currentRun) {
+        cleanup();
+        reject(new NotFoundError(`Run not found: ${runId}`));
+        return;
+      }
+      if (currentRun.status === "completed") {
+        cleanup();
+        resolve(currentRun);
+        return;
+      }
+      if (currentRun.status === "failed") {
+        cleanup();
+        reject(new Error(currentRun.error || "Run failed"));
+        return;
+      }
+      if (currentRun.status === "cancelled") {
+        cleanup();
+        reject(new CancelledError(runId));
+        return;
+      }
+      pollIntervalId = setInterval(poll, pollingMs);
+    }).catch((error) => {
+      if (resolved) return;
+      cleanup();
+      reject(toError(error));
+    });
+    if (options?.timeout !== void 0) {
+      timeoutId = setTimeout(() => {
+        if (!resolved) {
+          cleanup();
+          reject(
+            new Error(
+              `${timeoutMessagePrefix} timeout after ${options.timeout}ms`
+            )
+          );
+        }
+      }, options.timeout);
+    }
+  });
+}
+function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema, pollingIntervalMs) {
   const existingJob = registry.get(jobDef.name);
   if (existingJob) {
     if (existingJob.jobDef === jobDef) {
@@ -293,113 +303,77 @@ function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema)
   }
   const inputSchema = jobDef.input;
   const outputSchema = jobDef.output;
-  const handle = {
-    name: jobDef.name,
-    async trigger(input, options) {
-      const validatedInput = validateJobInputOrThrow(inputSchema, input);
-      if (labelsSchema && options?.labels) {
-        validateJobInputOrThrow(labelsSchema, options.labels, "labels");
-      }
-      const run = await storage.enqueue({
-        jobName: jobDef.name,
-        input: validatedInput,
-        idempotencyKey: options?.idempotencyKey,
-        concurrencyKey: options?.concurrencyKey,
-        labels: options?.labels
-      });
+  function validateCoalesceOption(coalesce, concurrencyKey, context) {
+    if (coalesce === void 0) return;
+    const suffix = context ? ` ${context}` : "";
+    if (coalesce !== "skip") {
+      throw new ValidationError(
+        `Invalid coalesce value${suffix}: '${coalesce}'. Valid values: 'skip'`
+      );
+    }
+    if (!concurrencyKey) {
+      throw new ValidationError(`coalesce requires concurrencyKey${suffix}`);
+    }
+  }
+  function emitDispositionEvent(disposition, run, input, labels) {
+    if (disposition === "created") {
       eventEmitter.emit({
         type: "run:trigger",
         runId: run.id,
         jobName: jobDef.name,
-        input: validatedInput,
+        input,
         labels: run.labels
       });
-      return run;
+    } else if (disposition === "coalesced") {
+      eventEmitter.emit({
+        type: "run:coalesced",
+        runId: run.id,
+        jobName: jobDef.name,
+        labels: run.labels,
+        skippedInput: input,
+        skippedLabels: labels ?? {}
+      });
+    }
+  }
+  const handle = {
+    name: jobDef.name,
+    async trigger(input, options) {
+      validateCoalesceOption(options?.coalesce, options?.concurrencyKey);
+      const validatedInput = validateJobInputOrThrow(inputSchema, input);
+      const validatedLabels = labelsSchema && options?.labels ? validateJobInputOrThrow(labelsSchema, options.labels, "labels") : options?.labels;
+      const { run, disposition } = await storage.enqueue({
+        jobName: jobDef.name,
+        input: validatedInput,
+        idempotencyKey: options?.idempotencyKey,
+        concurrencyKey: options?.concurrencyKey,
+        labels: validatedLabels,
+        coalesce: options?.coalesce
+      });
+      emitDispositionEvent(
+        disposition,
+        run,
+        validatedInput,
+        validatedLabels
+      );
+      return { ...run, disposition };
     },
     async triggerAndWait(input, options) {
       const run = await this.trigger(input, options);
-      return new Promise((resolve, reject) => {
-        let timeoutId;
-        let resolved = false;
-        const unsubscribes = [];
-        const cleanup = () => {
-          if (resolved) return;
-          resolved = true;
-          for (const unsub of unsubscribes) unsub();
-          if (timeoutId) {
-            clearTimeout(timeoutId);
-          }
-        };
-        unsubscribes.push(
-          eventEmitter.on("run:complete", (event) => {
-            if (event.runId === run.id && !resolved) {
-              cleanup();
-              resolve({
-                id: run.id,
-                output: event.output
-              });
-            }
-          })
-        );
-        unsubscribes.push(
-          eventEmitter.on("run:fail", (event) => {
-            if (event.runId === run.id && !resolved) {
-              cleanup();
-              reject(new Error(event.error));
-            }
-          })
-        );
-        if (options?.onProgress) {
-          const onProgress = options.onProgress;
-          unsubscribes.push(
-            eventEmitter.on("run:progress", (event) => {
-              if (event.runId === run.id && !resolved) {
-                void Promise.resolve(onProgress(event.progress)).catch(noop);
-              }
-            })
-          );
-        }
-        if (options?.onLog) {
-          const onLog = options.onLog;
-          unsubscribes.push(
-            eventEmitter.on("log:write", (event) => {
-              if (event.runId === run.id && !resolved) {
-                const { level, message, data, stepName } = event;
-                void Promise.resolve(
-                  onLog({ level, message, data, stepName })
-                ).catch(noop);
-              }
-            })
-          );
-        }
-        storage.getRun(run.id).then((currentRun) => {
-          if (resolved || !currentRun) return;
-          if (currentRun.status === "completed") {
-            cleanup();
-            resolve({
-              id: run.id,
-              output: currentRun.output
-            });
-          } else if (currentRun.status === "failed") {
-            cleanup();
-            reject(new Error(currentRun.error || "Run failed"));
-          }
-        }).catch((error) => {
-          if (resolved) return;
-          cleanup();
-          reject(error instanceof Error ? error : new Error(String(error)));
-        });
-        if (options?.timeout !== void 0) {
-          timeoutId = setTimeout(() => {
-            if (!resolved) {
-              cleanup();
-              reject(
-                new Error(`triggerAndWait timeout after ${options.timeout}ms`)
-              );
-            }
-          }, options.timeout);
-        }
-      });
+      const completedRun = await waitForRunCompletion(
+        run.id,
+        storage,
+        eventEmitter,
+        {
+          ...options,
+          pollingIntervalMs: options?.pollingIntervalMs ?? pollingIntervalMs
+        },
+        "triggerAndWait"
+      );
+      return {
+        id: run.id,
+        output: completedRun.output,
+        disposition: run.disposition
+      };
     },
     async batchTrigger(inputs) {
       if (inputs.length === 0) {
@@ -413,42 +387,51 @@ function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema)
       });
       const validated = [];
       for (let i = 0; i < normalized.length; i++) {
+        const opts = normalized[i].options;
+        validateCoalesceOption(
+          opts?.coalesce,
+          opts?.concurrencyKey,
+          `at index ${i}`
+        );
         const validatedInput = validateJobInputOrThrow(
           inputSchema,
           normalized[i].input,
           `at index ${i}`
         );
-        if (labelsSchema && normalized[i].options?.labels) {
-          validateJobInputOrThrow(
-            labelsSchema,
-            normalized[i].options?.labels,
-            `labels at index ${i}`
-          );
-        }
+        const validatedLabels = labelsSchema && opts?.labels ? validateJobInputOrThrow(
+          labelsSchema,
+          opts.labels,
+          `labels at index ${i}`
+        ) : opts?.labels;
         validated.push({
           input: validatedInput,
-          options: normalized[i].options
+          options: opts ? { ...opts, labels: validatedLabels } : opts
         });
       }
-      const runs = await storage.enqueueMany(
+      const results = await storage.enqueueMany(
         validated.map((v) => ({
           jobName: jobDef.name,
           input: v.input,
           idempotencyKey: v.options?.idempotencyKey,
           concurrencyKey: v.options?.concurrencyKey,
-          labels: v.options?.labels
+          labels: v.options?.labels,
+          coalesce: v.options?.coalesce
         }))
       );
-      for (let i = 0; i < runs.length; i++) {
-        eventEmitter.emit({
-          type: "run:trigger",
-          runId: runs[i].id,
-          jobName: jobDef.name,
-          input: validated[i].input,
-          labels: runs[i].labels
-        });
+      for (let i = 0; i < results.length; i++) {
+        emitDispositionEvent(
+          results[i].disposition,
+          results[i].run,
+          validated[i].input,
+          validated[i].options?.labels
+        );
       }
-      return runs;
+      return results.map(
+        (r) => ({
+          ...r.run,
+          disposition: r.disposition
+        })
+      );
     },
     async getRun(id) {
       const run = await storage.getRun(id);
@@ -487,6 +470,10 @@ var migrations = [
         "current_step_index",
         "integer",
         (col) => col.notNull().defaultTo(0)
+      ).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",
@@ -510,6 +497,11 @@ var migrations = [
       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();
+      await sql`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_durably_runs_pending_concurrency
+        ON durably_runs (job_name, concurrency_key)
+        WHERE status = 'pending' AND concurrency_key IS NOT NULL
+      `.execute(db);
     }
   }
 ];
@@ -536,34 +528,365 @@ async function runMigrations(db) {
   }
 }
 
-// src/storage.ts
-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,
-    leaseOwner,
-    leaseExpiresAt,
-    leaseGeneration,
-    updatedAt,
-    ...clientRun
-  } = run;
-  return clientRun;
+// 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
+  };
 }
-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/runtime.ts
+function isoNow(clock) {
+  return new Date(clock.now()).toISOString();
+}
+async function executeRun(run, job, config, environment) {
+  const { storage, eventEmitter, clock } = environment;
+  const { step, abortLeaseOwnership, dispose } = createStepContext(
+    run,
+    run.jobName,
+    run.leaseGeneration,
+    storage,
+    eventEmitter
+  );
+  let leaseDeadlineTimer = null;
+  const scheduleLeaseDeadline = (leaseExpiresAt) => {
+    if (leaseDeadlineTimer) {
+      clock.clearTimeout(leaseDeadlineTimer);
+      leaseDeadlineTimer = null;
+    }
+    if (!leaseExpiresAt) {
+      return;
+    }
+    const delay = Math.max(0, Date.parse(leaseExpiresAt) - clock.now());
+    leaseDeadlineTimer = clock.setTimeout(() => {
+      abortLeaseOwnership();
+    }, delay);
+  };
+  scheduleLeaseDeadline(run.leaseExpiresAt);
+  const leaseTimer = clock.setInterval(() => {
+    const now = isoNow(clock);
+    storage.renewLease(run.id, run.leaseGeneration, now, config.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) + config.leaseMs
+      ).toISOString();
+      scheduleLeaseDeadline(renewedLeaseExpiresAt);
+      eventEmitter.emit({
+        type: "run:lease-renewed",
+        runId: run.id,
+        jobName: run.jobName,
+        leaseOwner: run.leaseOwner ?? "",
+        leaseExpiresAt: renewedLeaseExpiresAt,
+        labels: run.labels
+      });
+    }).catch((error) => {
+      eventEmitter.emit({
+        type: "worker:error",
+        error: getErrorMessage(error),
+        context: "lease-renewal",
+        runId: run.id
+      });
+    });
+  }, config.leaseRenewIntervalMs);
+  const started = clock.now();
+  let reachedTerminalState = false;
+  try {
+    eventEmitter.emit({
+      type: "run:leased",
+      runId: run.id,
+      jobName: run.jobName,
+      input: run.input,
+      leaseOwner: run.leaseOwner ?? "",
+      leaseExpiresAt: run.leaseExpiresAt ?? isoNow(clock),
+      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 = isoNow(clock);
+    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: clock.now() - started,
+        labels: run.labels
+      });
+      return { kind: "completed" };
+    }
+    eventEmitter.emit({
+      type: "worker:error",
+      error: `Lease lost before completing run ${run.id}`,
+      context: "run-completion"
+    });
+    return { kind: "lease-lost" };
+  } catch (error) {
+    if (error instanceof LeaseLostError) {
+      return { kind: "lease-lost" };
+    }
+    if (error instanceof CancelledError) {
+      return { kind: "cancelled" };
+    }
+    const errorMessage = getErrorMessage(error);
+    const completedAt = isoNow(clock);
+    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
+      });
+      return { kind: "failed" };
+    }
+    eventEmitter.emit({
+      type: "worker:error",
+      error: `Lease lost before recording failure for run ${run.id}`,
+      context: "run-failure"
+    });
+    return { kind: "lease-lost" };
+  } finally {
+    clock.clearInterval(leaseTimer);
+    if (leaseDeadlineTimer) {
+      clock.clearTimeout(leaseDeadlineTimer);
+    }
+    dispose();
+    if (!config.preserveSteps && reachedTerminalState) {
+      await storage.deleteSteps(run.id);
     }
   }
 }
+
+// src/storage.ts
+import { sql as sql4 } from "kysely";
+import { monotonicFactory } from "ulidx";
+
+// src/claim-postgres.ts
+import { sql as sql2 } from "kysely";
+
+// src/transformers.ts
 function rowToRun(row) {
   return {
     id: row.id,
@@ -573,7 +896,7 @@ 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,
@@ -600,15 +923,135 @@ function rowToStep(row) {
     completedAt: row.completed_at
   };
 }
-function rowToLog(row) {
+function rowToLog(row) {
+  return {
+    id: row.id,
+    runId: row.run_id,
+    stepName: row.step_name,
+    level: row.level,
+    message: row.message,
+    data: row.data ? JSON.parse(row.data) : null,
+    createdAt: row.created_at
+  };
+}
+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 {
-    id: row.id,
-    runId: row.run_id,
-    stepName: row.step_name,
-    level: row.level,
-    message: row.message,
-    data: row.data ? JSON.parse(row.data) : null,
-    createdAt: row.created_at
+    ...clientRun,
+    isTerminal: TERMINAL_STATUSES.includes(run.status),
+    isActive: run.status === "pending" || run.status === "leased"
   };
 }
 function createWriteMutex() {
@@ -628,6 +1071,29 @@ function createWriteMutex() {
     }
   };
 }
+function isUniqueViolation(err) {
+  if (!(err instanceof Error)) return false;
+  const pgCode = err.code;
+  if (pgCode === "23505") return true;
+  if (err.constraint) return true;
+  if (/unique constraint/i.test(err.message)) return true;
+  return false;
+}
+function parseUniqueViolation(err) {
+  if (!(err instanceof Error)) return null;
+  const msg = err.message;
+  const pgConstraint = err.constraint;
+  if (pgConstraint) {
+    if (pgConstraint.includes("idempotency")) return "idempotency";
+    if (pgConstraint.includes("pending_concurrency"))
+      return "pending_concurrency";
+  }
+  if (/unique constraint/i.test(msg)) {
+    if (msg.includes("idempotency_key")) return "idempotency";
+    if (msg.includes("concurrency_key")) return "pending_concurrency";
+  }
+  return null;
+}
 function createKyselyStore(db, backend = "generic") {
   const withWriteLock = createWriteMutex();
   async function cascadeDeleteRuns(trx, ids) {
@@ -653,119 +1119,138 @@ function createKyselyStore(db, backend = "generic") {
     }).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();
+  function findPendingByConcurrencyKey(queryDb, jobName, concurrencyKey) {
+    return queryDb.selectFrom("durably_runs").selectAll().where("job_name", "=", jobName).where("concurrency_key", "=", concurrencyKey).where("status", "=", "pending").orderBy("created_at", "asc").orderBy("id", "asc").limit(1).executeTakeFirst();
+  }
+  async function enqueueInTx(trx, input, retried = false) {
+    const queryDb = trx ?? db;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (input.idempotencyKey) {
+      const existing = await queryDb.selectFrom("durably_runs").selectAll().where("job_name", "=", input.jobName).where("idempotency_key", "=", input.idempotencyKey).executeTakeFirst();
+      if (existing) {
+        return { run: rowToRun(existing), disposition: "idempotent" };
+      }
+    }
+    validateLabels(input.labels);
+    const id = ulid();
+    const row = {
+      id,
+      job_name: input.jobName,
+      input: JSON.stringify(input.input),
+      status: "pending",
+      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 ?? {}),
+      lease_owner: null,
+      lease_expires_at: null,
+      lease_generation: 0,
+      started_at: null,
+      completed_at: null,
+      created_at: now,
+      updated_at: now
+    };
+    const doInsert = async (insertDb) => {
+      await sql4`SAVEPOINT sp_enqueue`.execute(insertDb);
+      try {
+        await insertDb.insertInto("durably_runs").values(row).execute();
+        await insertLabelRows(insertDb, id, input.labels);
+        await sql4`RELEASE SAVEPOINT sp_enqueue`.execute(insertDb);
+      } catch (err) {
+        await sql4`ROLLBACK TO SAVEPOINT sp_enqueue`.execute(insertDb);
+        throw err;
+      }
+    };
+    try {
+      if (trx) {
+        await doInsert(trx);
+      } else {
+        await db.transaction().execute(doInsert);
+      }
+      return { run: rowToRun(row), disposition: "created" };
+    } catch (err) {
+      if (!isUniqueViolation(err)) throw err;
+      const violation = parseUniqueViolation(err);
       if (input.idempotencyKey) {
-        const existing = await db.selectFrom("durably_runs").selectAll().where("job_name", "=", input.jobName).where("idempotency_key", "=", input.idempotencyKey).executeTakeFirst();
-        if (existing) {
-          return rowToRun(existing);
+        const idempotent = await queryDb.selectFrom("durably_runs").selectAll().where("job_name", "=", input.jobName).where("idempotency_key", "=", input.idempotencyKey).executeTakeFirst();
+        if (idempotent) {
+          return { run: rowToRun(idempotent), disposition: "idempotent" };
         }
       }
-      validateLabels(input.labels);
-      const id = ulid();
-      const run = {
-        id,
-        job_name: input.jobName,
-        input: JSON.stringify(input.input),
-        status: "pending",
-        idempotency_key: input.idempotencyKey ?? null,
-        concurrency_key: input.concurrencyKey ?? null,
-        current_step_index: 0,
-        progress: null,
-        output: null,
-        error: null,
-        labels: JSON.stringify(input.labels ?? {}),
-        lease_owner: null,
-        lease_expires_at: null,
-        lease_generation: 0,
-        started_at: null,
-        completed_at: null,
-        created_at: now,
-        updated_at: now
-      };
-      await db.transaction().execute(async (trx) => {
-        await trx.insertInto("durably_runs").values(run).execute();
-        await insertLabelRows(trx, id, input.labels);
-      });
-      return rowToRun(run);
+      if ((violation === "pending_concurrency" || violation === null) && input.concurrencyKey) {
+        if (input.coalesce === "skip") {
+          const pending = await findPendingByConcurrencyKey(
+            queryDb,
+            input.jobName,
+            input.concurrencyKey
+          );
+          if (pending) {
+            return { run: rowToRun(pending), disposition: "coalesced" };
+          }
+          if (!retried) {
+            return enqueueInTx(trx, input, true);
+          }
+          const lastChance = await findPendingByConcurrencyKey(
+            queryDb,
+            input.jobName,
+            input.concurrencyKey
+          );
+          if (lastChance) {
+            return { run: rowToRun(lastChance), disposition: "coalesced" };
+          }
+          throw new ConflictError(
+            `Conflict after retry for concurrency key "${input.concurrencyKey}" in job "${input.jobName}". Concurrent modification detected.`
+          );
+        }
+        throw new ConflictError(
+          `A pending run already exists for concurrency key "${input.concurrencyKey}" in job "${input.jobName}". Use coalesce: 'skip' to return the existing run instead.`
+        );
+      }
+      throw err;
+    }
+  }
+  const store = {
+    async enqueue(input) {
+      return enqueueInTx(null, input);
     },
     async enqueueMany(inputs) {
       if (inputs.length === 0) {
         return [];
       }
-      return await db.transaction().execute(async (trx) => {
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const runs = [];
+      return db.transaction().execute(async (trx) => {
+        const results = [];
         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();
-            if (existing) {
-              runs.push(existing);
-              continue;
-            }
-          }
-          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,
-            input: JSON.stringify(input.input),
-            status: "pending",
-            idempotency_key: input.idempotencyKey ?? null,
-            concurrency_key: input.concurrencyKey ?? null,
-            current_step_index: 0,
-            progress: null,
-            output: null,
-            error: null,
-            labels: JSON.stringify(input.labels ?? {}),
-            lease_owner: null,
-            lease_expires_at: null,
-            lease_generation: 0,
-            started_at: null,
-            completed_at: null,
-            created_at: now,
-            updated_at: now
-          });
-        }
-        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();
-          }
+          results.push(await enqueueInTx(trx, input));
         }
-        return runs.map(rowToRun);
+        return results;
       });
     },
     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);
+        if (Array.isArray(filter.status)) {
+          if (filter.status.length > 0) {
+            query = query.where("status", "in", filter.status);
+          }
+        } else {
+          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) {
@@ -773,18 +1258,14 @@ function createKyselyStore(db, backend = "generic") {
         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(
-            (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
-            ])
+            (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);
       }
@@ -830,7 +1311,7 @@ function createKyselyStore(db, backend = "generic") {
     },
     async claimNext(workerId, now, leaseMs) {
       const leaseExpiresAt = new Date(Date.parse(now) + leaseMs).toISOString();
-      const activeLeaseGuard = sql2`
+      const activeLeaseGuard = sql4`
         (
           concurrency_key IS NULL
           OR NOT EXISTS (
@@ -844,92 +1325,7 @@ function createKyselyStore(db, backend = "generic") {
           )
         )
       `;
-      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: "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",
-        "=",
-        (eb) => eb.selectFrom(subquery.as("sub")).select("id")
-      ).returningAll().executeTakeFirst();
-      if (!row) return null;
-      return rowToRun({ ...row, step_count: 0 });
+      return backend === "postgres" ? claimNextPostgres(db, workerId, now, leaseExpiresAt, activeLeaseGuard) : claimNextSqlite(db, workerId, now, leaseExpiresAt, activeLeaseGuard);
     },
     async renewLease(runId, leaseGeneration, now, leaseMs) {
       const leaseExpiresAt = new Date(Date.parse(now) + leaseMs).toISOString();
@@ -940,13 +1336,54 @@ function createKyselyStore(db, backend = "generic") {
       return Number(result.numUpdatedRows) > 0;
     },
     async releaseExpiredLeases(now) {
-      const result = await db.updateTable("durably_runs").set({
-        status: "pending",
+      const conflicting = await db.updateTable("durably_runs").set({
+        status: "failed",
+        error: "Lease expired; pending run already exists",
         lease_owner: null,
         lease_expires_at: null,
+        completed_at: now,
         updated_at: now
-      }).where("status", "=", "leased").where("lease_expires_at", "is not", null).where("lease_expires_at", "<=", now).executeTakeFirst();
-      return Number(result.numUpdatedRows);
+      }).where("status", "=", "leased").where("lease_expires_at", "is not", null).where("lease_expires_at", "<=", now).where(
+        ({ exists, selectFrom }) => exists(
+          selectFrom("durably_runs as other").select(sql4.lit(1).as("one")).whereRef("other.job_name", "=", "durably_runs.job_name").whereRef(
+            "other.concurrency_key",
+            "=",
+            "durably_runs.concurrency_key"
+          ).where("other.status", "=", "pending").whereRef("other.id", "<>", "durably_runs.id")
+        )
+      ).executeTakeFirst();
+      let count = Number(conflicting.numUpdatedRows);
+      const remaining = await db.selectFrom("durably_runs").select("id").where("status", "=", "leased").where("lease_expires_at", "is not", null).where("lease_expires_at", "<=", now).execute();
+      if (remaining.length > 0) {
+        await db.transaction().execute(async (trx) => {
+          for (const row of remaining) {
+            try {
+              await sql4`SAVEPOINT sp_release`.execute(trx);
+              const reset = await trx.updateTable("durably_runs").set({
+                status: "pending",
+                lease_owner: null,
+                lease_expires_at: null,
+                updated_at: now
+              }).where("id", "=", row.id).where("status", "=", "leased").where("lease_expires_at", "<=", now).executeTakeFirst();
+              await sql4`RELEASE SAVEPOINT sp_release`.execute(trx);
+              count += Number(reset.numUpdatedRows);
+            } catch (err) {
+              await sql4`ROLLBACK TO SAVEPOINT sp_release`.execute(trx);
+              if (!isUniqueViolation(err)) throw err;
+              const failed = await trx.updateTable("durably_runs").set({
+                status: "failed",
+                error: "Lease expired; pending run already exists",
+                lease_owner: null,
+                lease_expires_at: null,
+                completed_at: now,
+                updated_at: now
+              }).where("id", "=", row.id).where("status", "=", "leased").executeTakeFirst();
+              count += Number(failed.numUpdatedRows);
+            }
+          }
+        });
+      }
+      return count;
     },
     async completeRun(runId, leaseGeneration, output, completedAt) {
       return terminateRun(runId, leaseGeneration, completedAt, {
@@ -977,19 +1414,20 @@ function createKyselyStore(db, backend = "generic") {
       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`
+        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 lease_generation = ${leaseGeneration}
+          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("lease_generation", "=", leaseGeneration).execute();
+          }).where("id", "=", runId).where("status", "=", "leased").where("lease_generation", "=", leaseGeneration).execute();
         }
         return {
           id,
@@ -1020,7 +1458,7 @@ function createKyselyStore(db, backend = "generic") {
       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();
+      }).where("id", "=", runId).where("status", "=", "leased").where("lease_generation", "=", leaseGeneration).execute();
     },
     async createLog(input) {
       const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1042,56 +1480,107 @@ function createKyselyStore(db, backend = "generic") {
       return rows.map(rowToLog);
     }
   };
-  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));
+  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, processOne) {
+function createWorker(config, processOne, onIdle) {
+  const maxConcurrentRuns = config.maxConcurrentRuns;
   let running = false;
   let pollingTimeout = null;
-  let inFlight = null;
-  let stopResolver = null;
+  let activeCount = 0;
   let activeWorkerId;
-  async function poll() {
+  const activePromises = /* @__PURE__ */ new Set();
+  let idleMaintenanceInFlight = null;
+  function scheduleDelayedPoll() {
     if (!running) {
       return;
     }
+    if (pollingTimeout) {
+      clearTimeout(pollingTimeout);
+      pollingTimeout = null;
+    }
+    pollingTimeout = setTimeout(() => {
+      pollingTimeout = null;
+      if (running) {
+        fillSlots();
+      }
+    }, config.pollingIntervalMs);
+  }
+  async function runIdleMaintenanceSafe() {
+    if (!onIdle) {
+      return;
+    }
+    const cycle = (async () => {
+      try {
+        await onIdle();
+      } catch {
+      }
+    })();
+    idleMaintenanceInFlight = cycle;
     try {
-      inFlight = processOne({ workerId: activeWorkerId }).then(() => void 0);
-      await inFlight;
+      await cycle;
     } finally {
-      inFlight = null;
+      if (idleMaintenanceInFlight === cycle) {
+        idleMaintenanceInFlight = null;
+      }
+    }
+  }
+  async function processSlotCycle() {
+    try {
+      const didProcess = await processOne({ workerId: activeWorkerId });
+      activeCount--;
+      if (didProcess && running) {
+        fillSlots();
+      } else if (!didProcess && running) {
+        if (activeCount === 0) {
+          await runIdleMaintenanceSafe();
+        }
+        scheduleDelayedPoll();
+      }
+    } catch (err) {
+      activeCount--;
+      if (running) {
+        fillSlots();
+      }
+      throw err;
     }
-    if (running) {
-      pollingTimeout = setTimeout(() => {
-        void poll();
-      }, config.pollingIntervalMs);
+  }
+  function fillSlots() {
+    if (!running) {
       return;
     }
-    if (stopResolver) {
-      stopResolver();
-      stopResolver = null;
+    while (running && activeCount < maxConcurrentRuns) {
+      activeCount++;
+      const p = processSlotCycle();
+      activePromises.add(p);
+      void p.finally(() => {
+        activePromises.delete(p);
+      }).catch(() => {
+      });
     }
   }
   return {
@@ -1104,7 +1593,7 @@ function createWorker(config, processOne) {
       }
       activeWorkerId = options?.workerId;
       running = true;
-      void poll();
+      fillSlots();
     },
     async stop() {
       if (!running) {
@@ -1115,11 +1604,14 @@ function createWorker(config, processOne) {
         clearTimeout(pollingTimeout);
         pollingTimeout = null;
       }
-      if (inFlight) {
-        return new Promise((resolve) => {
-          stopResolver = resolve;
-        });
+      const pending = [...activePromises];
+      if (idleMaintenanceInFlight) {
+        pending.push(idleMaintenanceInFlight);
+      }
+      if (pending.length === 0) {
+        return;
       }
+      await Promise.allSettled(pending);
     }
   };
 }
@@ -1127,10 +1619,20 @@ function createWorker(config, processOne) {
 // src/durably.ts
 var DEFAULTS = {
   pollingIntervalMs: 1e3,
+  maxConcurrentRuns: 1,
   leaseRenewIntervalMs: 5e3,
   leaseMs: 3e4,
   preserveSteps: false
 };
+var MAX_CONCURRENT_RUNS = 1e3;
+function validateMaxConcurrentRuns(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_CONCURRENT_RUNS) {
+    throw new ValidationError(
+      `maxConcurrentRuns must be between 1 and ${MAX_CONCURRENT_RUNS}`
+    );
+  }
+  return value;
+}
 function parseDuration(value) {
   const match = value.match(/^(\d+)(d|h|m)$/);
   if (!match) {
@@ -1148,6 +1650,14 @@ function parseDuration(value) {
   return num * multipliers[unit];
 }
 var PURGE_INTERVAL_MS = 6e4;
+var CHECKPOINT_INTERVAL_MS = 6e4;
+var realClock = {
+  now: () => Date.now(),
+  setTimeout: (fn, ms) => globalThis.setTimeout(fn, ms),
+  clearTimeout: (id) => globalThis.clearTimeout(id),
+  setInterval: (fn, ms) => globalThis.setInterval(fn, ms),
+  clearInterval: (id) => globalThis.clearInterval(id)
+};
 var ulid2 = monotonicFactory2();
 var BROWSER_SINGLETON_REGISTRY_KEY = "__durablyBrowserSingletonRegistry";
 var BROWSER_LOCAL_DIALECT_KEY = "__durablyBrowserLocalKey";
@@ -1213,11 +1723,11 @@ function createDurablyInstance(state, jobs) {
   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) {
+  async function executeRun2(run, _workerId) {
     const job = jobRegistry.get(run.jobName);
     if (!job) {
       await storage.failRun(
@@ -1228,146 +1738,16 @@ function createDurablyInstance(state, jobs) {
       );
       return;
     }
-    const { step, abortLeaseOwnership, dispose } = createStepContext(
+    await executeRun(
       run,
-      run.jobName,
-      run.leaseGeneration,
-      storage,
-      eventEmitter
+      job,
+      {
+        leaseMs: state.leaseMs,
+        leaseRenewIntervalMs: state.leaseRenewIntervalMs,
+        preserveSteps: state.preserveSteps
+      },
+      { storage, eventEmitter, clock: realClock }
     );
-    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,
@@ -1391,7 +1771,8 @@ function createDurablyInstance(state, jobs) {
           storage,
           eventEmitter,
           jobRegistry,
-          state.labelsSchema
+          state.labelsSchema,
+          state.pollingIntervalMs
         );
         newHandles[key] = handle;
       }
@@ -1403,6 +1784,19 @@ function createDurablyInstance(state, jobs) {
     },
     getRun: storage.getRun.bind(storage),
     getRuns: storage.getRuns.bind(storage),
+    async waitForRun(runId, options) {
+      const run = await waitForRunCompletion(
+        runId,
+        storage,
+        eventEmitter,
+        {
+          ...options,
+          pollingIntervalMs: options?.pollingIntervalMs ?? state.pollingIntervalMs
+        },
+        "waitForRun"
+      );
+      return run;
+    },
     use(plugin) {
       plugin.install(durably);
     },
@@ -1520,21 +1914,21 @@ 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 === "leased") {
-        throw new Error(`Cannot retrigger leased run: ${runId}`);
+        throw new ConflictError(`Cannot retrigger leased run: ${runId}`);
       }
       const job = jobRegistry.get(run.jobName);
       if (!job) {
-        throw new Error(`Unknown job: ${run.jobName}`);
+        throw new NotFoundError(`Unknown job: ${run.jobName}`);
       }
       const validatedInput = validateJobInputOrThrow(
         job.inputSchema,
         run.input,
         `Cannot retrigger run ${runId}`
       );
-      const nextRun = await storage.enqueue({
+      const { run: nextRun } = await storage.enqueue({
         jobName: run.jobName,
         input: validatedInput,
         concurrencyKey: run.concurrencyKey ?? void 0,
@@ -1552,19 +1946,19 @@ 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";
       const cancelled = await storage.cancelRun(runId, (/* @__PURE__ */ new Date()).toISOString());
       if (!cancelled) {
         const current = await getRunOrThrow(runId);
-        throw new Error(
+        throw new ConflictError(
           `Cannot cancel run ${runId}: status changed to ${current.status}`
         );
       }
@@ -1581,10 +1975,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 === "leased") {
-        throw new Error(`Cannot delete leased run: ${runId}`);
+        throw new ConflictError(`Cannot delete leased run: ${runId}`);
       }
       await storage.deleteRun(runId);
       eventEmitter.emit({
@@ -1603,37 +1997,29 @@ function createDurablyInstance(state, jobs) {
     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);
+      await executeRun2(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() {
@@ -1643,8 +2029,10 @@ function createDurablyInstance(state, jobs) {
       if (state.migrating) {
         return state.migrating;
       }
-      state.migrating = runMigrations(db).then(() => {
+      state.migrating = runMigrations(db).then(async () => {
         state.migrated = true;
+        await state.probeWalCheckpoint?.();
+        state.probeWalCheckpoint = null;
       }).finally(() => {
         state.migrating = null;
       });
@@ -1658,8 +2046,10 @@ function createDurablyInstance(state, jobs) {
   return durably;
 }
 function createDurably(options) {
+  const maxConcurrentRuns = options.maxConcurrentRuns !== void 0 ? validateMaxConcurrentRuns(options.maxConcurrentRuns) : DEFAULTS.maxConcurrentRuns;
   const config = {
     pollingIntervalMs: options.pollingIntervalMs ?? DEFAULTS.pollingIntervalMs,
+    maxConcurrentRuns,
     leaseRenewIntervalMs: options.leaseRenewIntervalMs ?? DEFAULTS.leaseRenewIntervalMs,
     leaseMs: options.leaseMs ?? DEFAULTS.leaseMs,
     preserveSteps: options.preserveSteps ?? DEFAULTS.preserveSteps,
@@ -1681,15 +2071,60 @@ function createDurably(options) {
   });
   const eventEmitter = createEventEmitter();
   const jobRegistry = createJobRegistry();
+  let lastPurgeAt = 0;
+  let lastCheckpointAt = 0;
+  const runIdleMaintenance = async () => {
+    try {
+      const nowMs = Date.now();
+      await storage.releaseExpiredLeases(new Date(nowMs).toISOString());
+      if (config.retainRunsMs !== null) {
+        if (nowMs - lastPurgeAt >= PURGE_INTERVAL_MS) {
+          lastPurgeAt = nowMs;
+          const cutoff = new Date(nowMs - config.retainRunsMs).toISOString();
+          await storage.purgeRuns({ olderThan: cutoff, limit: 100 });
+        }
+      }
+      if (state.walCheckpointSupported) {
+        if (nowMs - lastCheckpointAt >= CHECKPOINT_INTERVAL_MS) {
+          lastCheckpointAt = nowMs;
+          try {
+            const result = await sql5`PRAGMA wal_checkpoint(TRUNCATE)`.execute(
+              db
+            );
+            const row = result.rows[0];
+            if (row?.busy !== 0) {
+              lastCheckpointAt = nowMs - CHECKPOINT_INTERVAL_MS / 2;
+            }
+          } catch (checkpointError) {
+            eventEmitter.emit({
+              type: "worker:error",
+              error: getErrorMessage(checkpointError),
+              context: "wal-checkpoint"
+            });
+          }
+        }
+      }
+    } catch (error) {
+      eventEmitter.emit({
+        type: "worker:error",
+        error: getErrorMessage(error),
+        context: "idle-maintenance"
+      });
+    }
+  };
   let processOneImpl = null;
   const worker = createWorker(
-    { pollingIntervalMs: config.pollingIntervalMs },
+    {
+      pollingIntervalMs: config.pollingIntervalMs,
+      maxConcurrentRuns: config.maxConcurrentRuns
+    },
     (runtimeOptions) => {
       if (!processOneImpl) {
         throw new Error("Durably runtime is not initialized");
       }
       return processOneImpl(runtimeOptions);
-    }
+    },
+    runIdleMaintenance
   );
   const state = {
     db,
@@ -1701,12 +2136,27 @@ function createDurably(options) {
     preserveSteps: config.preserveSteps,
     migrating: null,
     migrated: false,
+    walCheckpointSupported: false,
+    probeWalCheckpoint: null,
     leaseMs: config.leaseMs,
     leaseRenewIntervalMs: config.leaseRenewIntervalMs,
+    pollingIntervalMs: config.pollingIntervalMs,
     retainRunsMs: config.retainRunsMs,
-    lastPurgeAt: 0,
-    releaseBrowserSingleton
+    releaseBrowserSingleton,
+    runIdleMaintenance
   };
+  if (backend === "generic" && !isBrowserLikeEnvironment()) {
+    state.probeWalCheckpoint = async () => {
+      try {
+        const result = await sql5`PRAGMA wal_checkpoint(PASSIVE)`.execute(db);
+        const row = result.rows[0];
+        if (row && row.log !== -1) {
+          state.walCheckpointSupported = true;
+        }
+      } catch {
+      }
+    };
+  }
   const instance = createDurablyInstance(
     state,
     {}
@@ -1973,15 +2423,27 @@ function parseLabelsFromParams(searchParams) {
 }
 function parseRunFilter(url) {
   const jobNames = url.searchParams.getAll("jobName");
-  const statusParam = url.searchParams.get("status");
+  const statusParams = url.searchParams.getAll("status");
   const limitParam = url.searchParams.get("limit");
   const offsetParam = url.searchParams.get("offset");
   const labels = parseLabelsFromParams(url.searchParams);
-  if (statusParam && !VALID_STATUSES_SET.has(statusParam)) {
-    return errorResponse(
-      `Invalid status: ${statusParam}. Must be one of: ${VALID_STATUSES.join(", ")}`,
-      400
-    );
+  let status;
+  if (statusParams.length > 0) {
+    for (const s of statusParams) {
+      if (s === "") {
+        return errorResponse(
+          `Invalid status: empty value. Must be one of: ${VALID_STATUSES.join(", ")}`,
+          400
+        );
+      }
+      if (!VALID_STATUSES_SET.has(s)) {
+        return errorResponse(
+          `Invalid status: ${s}. Must be one of: ${VALID_STATUSES.join(", ")}`,
+          400
+        );
+      }
+    }
+    status = statusParams.length === 1 ? statusParams[0] : statusParams;
   }
   let limit;
   if (limitParam) {
@@ -2002,7 +2464,7 @@ function parseRunFilter(url) {
   }
   return {
     jobName: jobNames.length > 0 ? jobNames : void 0,
-    status: statusParam,
+    status,
     labels,
     limit,
     offset
@@ -2035,6 +2497,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);
     }
   }
@@ -2063,15 +2531,16 @@ 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 response = { runId: run.id };
+      const run = await job.trigger(body.input, {
+        idempotencyKey: body.idempotencyKey,
+        concurrencyKey: body.concurrencyKey,
+        labels: body.labels,
+        coalesce: body.coalesce
+      });
+      const response = {
+        runId: run.id,
+        disposition: run.disposition
+      };
       return jsonResponse(response);
     });
   }
@@ -2186,6 +2655,18 @@ function createDurablyHandler(durably, options) {
               });
             }
           }),
+          durably.on("run:coalesced", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "run:coalesced",
+                runId: event.runId,
+                jobName: event.jobName,
+                labels: event.labels,
+                skippedInput: event.skippedInput,
+                skippedLabels: event.skippedLabels
+              });
+            }
+          }),
           durably.on("run:leased", (event) => {
             if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
@@ -2355,11 +2836,16 @@ function createDurablyHandler(durably, options) {
 }
 export {
   CancelledError,
+  ConflictError,
+  DurablyError,
   LeaseLostError,
+  NotFoundError,
+  ValidationError,
   createDurably,
   createDurablyHandler,
   createKyselyStore,
   defineJob,
+  isDomainEvent,
   toClientRun,
   withLogPersistence
 };