@coji/durably 0.14.0 → 0.15.0

package/dist/index.js

@@ -3,7 +3,7 @@ import {
 } 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
@@ -52,6 +52,482 @@ 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;
+  let errorHandler = null;
+  return {
+    on(type, listener) {
+      if (!listeners.has(type)) {
+        listeners.set(type, /* @__PURE__ */ new Set());
+      }
+      const typeListeners = listeners.get(type);
+      typeListeners?.add(listener);
+      return () => {
+        typeListeners?.delete(listener);
+      };
+    },
+    onError(handler) {
+      errorHandler = handler;
+    },
+    emit(event) {
+      sequence++;
+      const fullEvent = {
+        ...event,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sequence
+      };
+      const typeListeners = listeners.get(event.type);
+      if (!typeListeners) {
+        return;
+      }
+      const reportError = (error) => errorHandler?.(toError(error), fullEvent);
+      for (const listener of typeListeners) {
+        try {
+          const result = listener(fullEvent);
+          if (result != null && typeof result.then === "function") {
+            ;
+            result.catch(reportError);
+          }
+        } catch (error) {
+          reportError(error);
+        }
+      }
+    }
+  };
+}
+
+// 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 ValidationError(
+      `${prefix}Invalid input: ${prettifyError(result.error)}`
+    );
+  }
+  return result.data;
+}
+function createJobRegistry() {
+  const jobs = /* @__PURE__ */ new Map();
+  return {
+    set(job) {
+      jobs.set(job.name, job);
+    },
+    get(name) {
+      return jobs.get(name);
+    },
+    has(name) {
+      return jobs.has(name);
+    }
+  };
+}
+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) {
+      return existingJob.handle;
+    }
+    throw new Error(
+      `Job "${jobDef.name}" is already registered with a different definition`
+    );
+  }
+  const inputSchema = jobDef.input;
+  const outputSchema = jobDef.output;
+  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,
+        labels: run.labels
+      });
+    } 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);
+      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) {
+        return [];
+      }
+      const normalized = inputs.map((item) => {
+        if (item && typeof item === "object" && "input" in item) {
+          return item;
+        }
+        return { input: item, options: void 0 };
+      });
+      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}`
+        );
+        const validatedLabels = labelsSchema && opts?.labels ? validateJobInputOrThrow(
+          labelsSchema,
+          opts.labels,
+          `labels at index ${i}`
+        ) : opts?.labels;
+        validated.push({
+          input: validatedInput,
+          options: opts ? { ...opts, labels: validatedLabels } : opts
+        });
+      }
+      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,
+          coalesce: v.options?.coalesce
+        }))
+      );
+      for (let i = 0; i < results.length; i++) {
+        emitDispositionEvent(
+          results[i].disposition,
+          results[i].run,
+          validated[i].input,
+          validated[i].options?.labels
+        );
+      }
+      return results.map(
+        (r) => ({
+          ...r.run,
+          disposition: r.disposition
+        })
+      );
+    },
+    async getRun(id) {
+      const run = await storage.getRun(id);
+      if (!run || run.jobName !== jobDef.name) {
+        return null;
+      }
+      return run;
+    },
+    async getRuns(filter) {
+      const runs = await storage.getRuns({
+        ...filter,
+        jobName: jobDef.name
+      });
+      return runs;
+    }
+  };
+  registry.set({
+    name: jobDef.name,
+    inputSchema,
+    outputSchema,
+    labelsSchema,
+    fn: jobDef.run,
+    jobDef,
+    handle
+  });
+  return handle;
+}
+
+// src/migrations.ts
+import { sql } from "kysely";
+var migrations = [
+  {
+    version: 1,
+    up: async (db) => {
+      await db.schema.createTable("durably_runs").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("job_name", "text", (col) => col.notNull()).addColumn("input", "text", (col) => col.notNull()).addColumn("status", "text", (col) => col.notNull()).addColumn("idempotency_key", "text").addColumn("concurrency_key", "text").addColumn("labels", "text", (col) => col.notNull().defaultTo("{}")).addColumn(
+        "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",
+        (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();
+      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);
+    }
+  }
+];
+async function getCurrentVersion(db) {
+  try {
+    const result = await db.selectFrom("durably_schema_versions").select("version").orderBy("version", "desc").limit(1).executeTakeFirst();
+    return result?.version ?? 0;
+  } catch {
+    return 0;
+  }
+}
+async function runMigrations(db) {
+  const currentVersion = await getCurrentVersion(db);
+  for (const migration of migrations) {
+    if (migration.version > currentVersion) {
+      await db.transaction().execute(async (trx) => {
+        await migration.up(trx);
+        await trx.insertInto("durably_schema_versions").values({
+          version: migration.version,
+          applied_at: (/* @__PURE__ */ new Date()).toISOString()
+        }).execute();
+      });
+    }
+  }
+}
+
 // src/context.ts
 var LEASE_LOST = "lease-lost";
 function createStepContext(run, jobName, leaseGeneration, storage, eventEmitter) {
@@ -250,335 +726,155 @@ function createStepContext(run, jobName, leaseGeneration, storage, eventEmitter)
   };
 }
 
-// src/events.ts
-function createEventEmitter() {
-  const listeners = /* @__PURE__ */ new Map();
-  let sequence = 0;
-  let errorHandler = null;
-  return {
-    on(type, listener) {
-      if (!listeners.has(type)) {
-        listeners.set(type, /* @__PURE__ */ new Set());
-      }
-      const typeListeners = listeners.get(type);
-      typeListeners?.add(listener);
-      return () => {
-        typeListeners?.delete(listener);
-      };
-    },
-    onError(handler) {
-      errorHandler = handler;
-    },
-    emit(event) {
-      sequence++;
-      const fullEvent = {
-        ...event,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        sequence
-      };
-      const typeListeners = listeners.get(event.type);
-      if (!typeListeners) {
-        return;
-      }
-      const reportError = (error) => errorHandler?.(toError(error), fullEvent);
-      for (const listener of typeListeners) {
-        try {
-          const result = listener(fullEvent);
-          if (result != null && typeof result.then === "function") {
-            ;
-            result.catch(reportError);
-          }
-        } catch (error) {
-          reportError(error);
-        }
-      }
-    }
-  };
-}
-
-// src/job.ts
-import { prettifyError } from "zod";
-var noop = () => {
-};
-function validateJobInputOrThrow(schema, input, context) {
-  const result = schema.safeParse(input);
-  if (!result.success) {
-    const prefix = context ? `${context}: ` : "";
-    throw new ValidationError(
-      `${prefix}Invalid input: ${prettifyError(result.error)}`
-    );
-  }
-  return result.data;
-}
-function createJobRegistry() {
-  const jobs = /* @__PURE__ */ new Map();
-  return {
-    set(job) {
-      jobs.set(job.name, job);
-    },
-    get(name) {
-      return jobs.get(name);
-    },
-    has(name) {
-      return jobs.has(name);
-    }
-  };
-}
-function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema) {
-  const existingJob = registry.get(jobDef.name);
-  if (existingJob) {
-    if (existingJob.jobDef === jobDef) {
-      return existingJob.handle;
-    }
-    throw new Error(
-      `Job "${jobDef.name}" is already registered with a different definition`
-    );
-  }
-  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
-      });
-      eventEmitter.emit({
-        type: "run:trigger",
-        runId: run.id,
-        jobName: jobDef.name,
-        input: validatedInput,
-        labels: run.labels
-      });
-      return run;
-    },
-    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(toError(error));
-        });
-        if (options?.timeout !== void 0) {
-          timeoutId = setTimeout(() => {
-            if (!resolved) {
-              cleanup();
-              reject(
-                new Error(`triggerAndWait timeout after ${options.timeout}ms`)
-              );
-            }
-          }, options.timeout);
-        }
-      });
-    },
-    async batchTrigger(inputs) {
-      if (inputs.length === 0) {
-        return [];
-      }
-      const normalized = inputs.map((item) => {
-        if (item && typeof item === "object" && "input" in item) {
-          return item;
-        }
-        return { input: item, options: void 0 };
-      });
-      const validated = [];
-      for (let i = 0; i < normalized.length; 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}`
-          );
-        }
-        validated.push({
-          input: validatedInput,
-          options: normalized[i].options
-        });
-      }
-      const runs = await storage.enqueueMany(
-        validated.map((v) => ({
-          jobName: jobDef.name,
-          input: v.input,
-          idempotencyKey: v.options?.idempotencyKey,
-          concurrencyKey: v.options?.concurrencyKey,
-          labels: v.options?.labels
-        }))
-      );
-      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
-        });
-      }
-      return runs;
-    },
-    async getRun(id) {
-      const run = await storage.getRun(id);
-      if (!run || run.jobName !== jobDef.name) {
-        return null;
-      }
-      return run;
-    },
-    async getRuns(filter) {
-      const runs = await storage.getRuns({
-        ...filter,
-        jobName: jobDef.name
-      });
-      return runs;
-    }
-  };
-  registry.set({
-    name: jobDef.name,
-    inputSchema,
-    outputSchema,
-    labelsSchema,
-    fn: jobDef.run,
-    jobDef,
-    handle
-  });
-  return handle;
-}
-
-// src/migrations.ts
-import { sql } from "kysely";
-var migrations = [
-  {
-    version: 1,
-    up: async (db) => {
-      await db.schema.createTable("durably_runs").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("job_name", "text", (col) => col.notNull()).addColumn("input", "text", (col) => col.notNull()).addColumn("status", "text", (col) => col.notNull()).addColumn("idempotency_key", "text").addColumn("concurrency_key", "text").addColumn("labels", "text", (col) => col.notNull().defaultTo("{}")).addColumn(
-        "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",
-        (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();
-    }
-  }
-];
-async function getCurrentVersion(db) {
-  try {
-    const result = await db.selectFrom("durably_schema_versions").select("version").orderBy("version", "desc").limit(1).executeTakeFirst();
-    return result?.version ?? 0;
-  } catch {
-    return 0;
-  }
+// src/runtime.ts
+function isoNow(clock) {
+  return new Date(clock.now()).toISOString();
 }
-async function runMigrations(db) {
-  const currentVersion = await getCurrentVersion(db);
-  for (const migration of migrations) {
-    if (migration.version > currentVersion) {
-      await db.transaction().execute(async (trx) => {
-        await migration.up(trx);
-        await trx.insertInto("durably_schema_versions").values({
-          version: migration.version,
-          applied_at: (/* @__PURE__ */ new Date()).toISOString()
-        }).execute();
+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);
     }
   }
 }
@@ -752,7 +1048,11 @@ function toClientRun(run) {
     updatedAt,
     ...clientRun
   } = run;
-  return clientRun;
+  return {
+    ...clientRun,
+    isTerminal: TERMINAL_STATUSES.includes(run.status),
+    isActive: run.status === "pending" || run.status === "leased"
+  };
 }
 function createWriteMutex() {
   let queue = Promise.resolve();
@@ -771,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) {
@@ -796,99 +1119,114 @@ 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,
-        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
-      };
-      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,
-            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 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) {
@@ -898,7 +1236,13 @@ function createKyselyStore(db, backend = "generic") {
     async getRuns(filter) {
       let query = db.selectFrom("durably_runs").selectAll();
       if (filter?.status) {
-        query = query.where("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)) {
@@ -992,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, {
@@ -1123,39 +1508,79 @@ function createKyselyStore(db, backend = "generic") {
 
 // src/worker.ts
 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 () => {
-      const didProcess = await processOne({ workerId: activeWorkerId });
-      if (!didProcess && onIdle && running) {
-        try {
-          await onIdle();
-        } catch {
-        }
+      try {
+        await onIdle();
+      } catch {
       }
     })();
-    inFlight = cycle;
+    idleMaintenanceInFlight = cycle;
     try {
       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 {
@@ -1168,7 +1593,7 @@ function createWorker(config, processOne, onIdle) {
       }
       activeWorkerId = options?.workerId;
       running = true;
-      void poll();
+      fillSlots();
     },
     async stop() {
       if (!running) {
@@ -1179,11 +1604,14 @@ function createWorker(config, processOne, onIdle) {
         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);
     }
   };
 }
@@ -1191,10 +1619,20 @@ function createWorker(config, processOne, onIdle) {
 // 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) {
@@ -1212,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";
@@ -1281,7 +1727,7 @@ function createDurablyInstance(state, jobs) {
     }
     return run;
   }
-  async function executeRun(run, workerId) {
+  async function executeRun2(run, _workerId) {
     const job = jobRegistry.get(run.jobName);
     if (!job) {
       await storage.failRun(
@@ -1292,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,
@@ -1455,7 +1771,8 @@ function createDurablyInstance(state, jobs) {
           storage,
           eventEmitter,
           jobRegistry,
-          state.labelsSchema
+          state.labelsSchema,
+          state.pollingIntervalMs
         );
         newHandles[key] = handle;
       }
@@ -1467,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);
     },
@@ -1598,7 +1928,7 @@ function createDurablyInstance(state, jobs) {
         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,
@@ -1671,7 +2001,7 @@ function createDurablyInstance(state, jobs) {
       if (!run) {
         return false;
       }
-      await executeRun(run, workerId);
+      await executeRun2(run, workerId);
       return true;
     },
     async processUntilIdle(options) {
@@ -1699,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;
       });
@@ -1714,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,
@@ -1738,18 +2072,38 @@ function createDurably(options) {
   const eventEmitter = createEventEmitter();
   const jobRegistry = createJobRegistry();
   let lastPurgeAt = 0;
+  let lastCheckpointAt = 0;
   const runIdleMaintenance = async () => {
     try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      await storage.releaseExpiredLeases(now);
+      const nowMs = Date.now();
+      await storage.releaseExpiredLeases(new Date(nowMs).toISOString());
       if (config.retainRunsMs !== null) {
-        const purgeNow = Date.now();
-        if (purgeNow - lastPurgeAt >= PURGE_INTERVAL_MS) {
-          lastPurgeAt = purgeNow;
-          const cutoff = new Date(purgeNow - config.retainRunsMs).toISOString();
+        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",
@@ -1760,7 +2114,10 @@ function createDurably(options) {
   };
   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");
@@ -1779,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,
     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,
     {}
@@ -2051,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) {
@@ -2080,7 +2464,7 @@ function parseRunFilter(url) {
   }
   return {
     jobName: jobNames.length > 0 ? jobNames : void 0,
-    status: statusParam,
+    status,
     labels,
     limit,
     offset
@@ -2150,9 +2534,13 @@ function createDurablyHandler(durably, options) {
       const run = await job.trigger(body.input, {
         idempotencyKey: body.idempotencyKey,
         concurrencyKey: body.concurrencyKey,
-        labels: body.labels
+        labels: body.labels,
+        coalesce: body.coalesce
       });
-      const response = { runId: run.id };
+      const response = {
+        runId: run.id,
+        disposition: run.disposition
+      };
       return jsonResponse(response);
     });
   }
@@ -2267,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({
@@ -2445,6 +2845,7 @@ export {
   createDurablyHandler,
   createKyselyStore,
   defineJob,
+  isDomainEvent,
   toClientRun,
   withLogPersistence
 };