@coji/durably 0.13.0 → 0.14.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   withLogPersistence
-} from "./chunk-UCUP6NMJ.js";
+} from "./chunk-L42OCQEV.js";
 
 // src/durably.ts
 import { Kysely } from "kysely";
@@ -19,9 +19,38 @@ 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);
 }
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
 
 // src/context.ts
 var LEASE_LOST = "lease-lost";
@@ -43,6 +72,22 @@ function createStepContext(run, jobName, leaseGeneration, storage, eventEmitter)
     }
     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();
@@ -100,8 +145,7 @@ function createStepContext(run, jobName, leaseGeneration, storage, eventEmitter)
           startedAt
         });
         if (!savedStep) {
-          abortForLeaseLoss();
-          throwIfAborted();
+          await throwForRefusedStep(name, stepIndex);
         }
         stepIndex++;
         eventEmitter.emit({
@@ -133,20 +177,17 @@ function createStepContext(run, jobName, leaseGeneration, storage, eventEmitter)
           startedAt
         });
         if (!savedStep) {
-          abortForLeaseLoss();
-          throw new LeaseLostError(run.id);
+          await throwForRefusedStep(name, stepIndex);
         }
         eventEmitter.emit({
-          ...isCancelled ? { type: "step:cancel" } : { type: "step:fail", error: errorMessage },
+          type: "step:fail",
+          error: errorMessage,
           runId: run.id,
           jobName,
           stepName: name,
           stepIndex,
           labels: run.labels
         });
-        if (isCancelled) {
-          throwIfAborted();
-        }
         throw error;
       } finally {
         currentStepName = null;
@@ -239,16 +280,16 @@ function createEventEmitter() {
       if (!typeListeners) {
         return;
       }
+      const reportError = (error) => errorHandler?.(toError(error), fullEvent);
       for (const listener of typeListeners) {
         try {
-          listener(fullEvent);
-        } catch (error) {
-          if (errorHandler) {
-            errorHandler(
-              error instanceof Error ? error : new Error(String(error)),
-              fullEvent
-            );
+          const result = listener(fullEvent);
+          if (result != null && typeof result.then === "function") {
+            ;
+            result.catch(reportError);
           }
+        } catch (error) {
+          reportError(error);
         }
       }
     }
@@ -263,7 +304,9 @@ function validateJobInputOrThrow(schema, input, context) {
   const result = schema.safeParse(input);
   if (!result.success) {
     const prefix = context ? `${context}: ` : "";
-    throw new Error(`${prefix}Invalid input: ${prettifyError(result.error)}`);
+    throw new ValidationError(
+      `${prefix}Invalid input: ${prettifyError(result.error)}`
+    );
   }
   return result.data;
 }
@@ -387,7 +430,7 @@ function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema)
         }).catch((error) => {
           if (resolved) return;
           cleanup();
-          reject(error instanceof Error ? error : new Error(String(error)));
+          reject(toError(error));
         });
         if (options?.timeout !== void 0) {
           timeoutId = setTimeout(() => {
@@ -487,6 +530,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",
@@ -537,33 +584,13 @@ async function runMigrations(db) {
 }
 
 // src/storage.ts
-import { sql as sql2 } from "kysely";
+import { sql as sql4 } 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;
-}
-var LABEL_KEY_PATTERN = /^[a-zA-Z0-9\-_./]+$/;
-function validateLabels(labels) {
-  if (!labels) return;
-  for (const key of Object.keys(labels)) {
-    if (!LABEL_KEY_PATTERN.test(key)) {
-      throw new Error(
-        `Invalid label key "${key}": must contain only alphanumeric characters, dashes, underscores, dots, and slashes`
-      );
-    }
-  }
-}
+
+// src/claim-postgres.ts
+import { sql as sql2 } from "kysely";
+
+// src/transformers.ts
 function rowToRun(row) {
   return {
     id: row.id,
@@ -573,7 +600,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,
@@ -611,6 +638,122 @@ function rowToLog(row) {
     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 clientRun;
+}
 function createWriteMutex() {
   let queue = Promise.resolve();
   return async function withWriteLock(fn) {
@@ -672,6 +815,7 @@ function createKyselyStore(db, backend = "generic") {
         idempotency_key: input.idempotencyKey ?? null,
         concurrency_key: input.concurrencyKey ?? null,
         current_step_index: 0,
+        completed_step_count: 0,
         progress: null,
         output: null,
         error: null,
@@ -723,6 +867,7 @@ function createKyselyStore(db, backend = "generic") {
             idempotency_key: input.idempotencyKey ?? null,
             concurrency_key: input.concurrencyKey ?? null,
             current_step_index: 0,
+            completed_step_count: 0,
             progress: null,
             output: null,
             error: null,
@@ -747,25 +892,21 @@ function createKyselyStore(db, backend = "generic") {
       });
     },
     async getRun(runId) {
-      const row = await db.selectFrom("durably_runs").leftJoin("durably_steps", "durably_runs.id", "durably_steps.run_id").selectAll("durably_runs").select(
-        (eb) => eb.fn.count("durably_steps.id").as("step_count")
-      ).where("durably_runs.id", "=", runId).groupBy("durably_runs.id").executeTakeFirst();
+      const row = await db.selectFrom("durably_runs").selectAll().where("id", "=", runId).executeTakeFirst();
       return row ? rowToRun(row) : null;
     },
     async getRuns(filter) {
-      let query = db.selectFrom("durably_runs").leftJoin("durably_steps", "durably_runs.id", "durably_steps.run_id").selectAll("durably_runs").select(
-        (eb) => eb.fn.count("durably_steps.id").as("step_count")
-      ).groupBy("durably_runs.id");
+      let query = db.selectFrom("durably_runs").selectAll();
       if (filter?.status) {
-        query = query.where("durably_runs.status", "=", filter.status);
+        query = query.where("status", "=", filter.status);
       }
       if (filter?.jobName) {
         if (Array.isArray(filter.jobName)) {
           if (filter.jobName.length > 0) {
-            query = query.where("durably_runs.job_name", "in", filter.jobName);
+            query = query.where("job_name", "in", filter.jobName);
           }
         } else {
-          query = query.where("durably_runs.job_name", "=", filter.jobName);
+          query = query.where("job_name", "=", filter.jobName);
         }
       }
       if (filter?.labels) {
@@ -773,18 +914,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 +967,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 +981,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();
@@ -977,19 +1029,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 +1073,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,32 +1095,34 @@ 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) {
   let running = false;
   let pollingTimeout = null;
   let inFlight = null;
@@ -1077,9 +1132,18 @@ function createWorker(config, processOne) {
     if (!running) {
       return;
     }
+    const cycle = (async () => {
+      const didProcess = await processOne({ workerId: activeWorkerId });
+      if (!didProcess && onIdle && running) {
+        try {
+          await onIdle();
+        } catch {
+        }
+      }
+    })();
+    inFlight = cycle;
     try {
-      inFlight = processOne({ workerId: activeWorkerId }).then(() => void 0);
-      await inFlight;
+      await cycle;
     } finally {
       inFlight = null;
     }
@@ -1213,7 +1277,7 @@ 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;
   }
@@ -1520,14 +1584,14 @@ 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,
@@ -1552,19 +1616,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 +1645,10 @@ function createDurablyInstance(state, jobs) {
     async deleteRun(runId) {
       const run = await getRunOrThrow(runId);
       if (run.status === "pending") {
-        throw new Error(`Cannot delete pending run: ${runId}`);
+        throw new ConflictError(`Cannot delete pending run: ${runId}`);
       }
       if (run.status === "leased") {
-        throw new Error(`Cannot delete leased run: ${runId}`);
+        throw new ConflictError(`Cannot delete leased run: ${runId}`);
       }
       await storage.deleteRun(runId);
       eventEmitter.emit({
@@ -1603,21 +1667,8 @@ 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);
@@ -1627,13 +1678,18 @@ function createDurablyInstance(state, jobs) {
       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() {
@@ -1681,6 +1737,27 @@ function createDurably(options) {
   });
   const eventEmitter = createEventEmitter();
   const jobRegistry = createJobRegistry();
+  let lastPurgeAt = 0;
+  const runIdleMaintenance = async () => {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await storage.releaseExpiredLeases(now);
+      if (config.retainRunsMs !== null) {
+        const purgeNow = Date.now();
+        if (purgeNow - lastPurgeAt >= PURGE_INTERVAL_MS) {
+          lastPurgeAt = purgeNow;
+          const cutoff = new Date(purgeNow - config.retainRunsMs).toISOString();
+          await storage.purgeRuns({ olderThan: cutoff, limit: 100 });
+        }
+      }
+    } catch (error) {
+      eventEmitter.emit({
+        type: "worker:error",
+        error: getErrorMessage(error),
+        context: "idle-maintenance"
+      });
+    }
+  };
   let processOneImpl = null;
   const worker = createWorker(
     { pollingIntervalMs: config.pollingIntervalMs },
@@ -1689,7 +1766,8 @@ function createDurably(options) {
         throw new Error("Durably runtime is not initialized");
       }
       return processOneImpl(runtimeOptions);
-    }
+    },
+    runIdleMaintenance
   );
   const state = {
     db,
@@ -1704,8 +1782,8 @@ function createDurably(options) {
     leaseMs: config.leaseMs,
     leaseRenewIntervalMs: config.leaseRenewIntervalMs,
     retainRunsMs: config.retainRunsMs,
-    lastPurgeAt: 0,
-    releaseBrowserSingleton
+    releaseBrowserSingleton,
+    runIdleMaintenance
   };
   const instance = createDurablyInstance(
     state,
@@ -2035,6 +2113,12 @@ function createDurablyHandler(durably, options) {
       return await fn();
     } catch (error) {
       if (error instanceof Response) throw error;
+      if (error instanceof DurablyError) {
+        return errorResponse(
+          error.message,
+          error.statusCode
+        );
+      }
       return errorResponse(getErrorMessage(error), 500);
     }
   }
@@ -2063,14 +2147,11 @@ function createDurablyHandler(durably, options) {
       if (auth?.onTrigger && ctx !== void 0) {
         await auth.onTrigger(ctx, body);
       }
-      const run = await job.trigger(
-        body.input ?? {},
-        {
-          idempotencyKey: body.idempotencyKey,
-          concurrencyKey: body.concurrencyKey,
-          labels: body.labels
-        }
-      );
+      const run = await job.trigger(body.input, {
+        idempotencyKey: body.idempotencyKey,
+        concurrencyKey: body.concurrencyKey,
+        labels: body.labels
+      });
       const response = { runId: run.id };
       return jsonResponse(response);
     });
@@ -2355,7 +2436,11 @@ function createDurablyHandler(durably, options) {
 }
 export {
   CancelledError,
+  ConflictError,
+  DurablyError,
   LeaseLostError,
+  NotFoundError,
+  ValidationError,
   createDurably,
   createDurablyHandler,
   createKyselyStore,