@coji/durably 0.10.0 → 0.12.0

package/dist/index.js

@@ -53,6 +53,8 @@ function createEventEmitter() {
 
 // src/job.ts
 import { prettifyError } from "zod";
+var noop = () => {
+};
 function validateJobInputOrThrow(schema, input, context) {
   const result = schema.safeParse(input);
   if (!result.success) {
@@ -75,7 +77,7 @@ function createJobRegistry() {
     }
   };
 }
-function createJobHandle(jobDef, storage, eventEmitter, registry) {
+function createJobHandle(jobDef, storage, eventEmitter, registry, labelsSchema) {
   const existingJob = registry.get(jobDef.name);
   if (existingJob) {
     if (existingJob.jobDef === jobDef) {
@@ -91,6 +93,9 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
     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.createRun({
         jobName: jobDef.name,
         input: validatedInput,
@@ -112,30 +117,57 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
       return new Promise((resolve, reject) => {
         let timeoutId;
         let resolved = false;
+        const unsubscribes = [];
         const cleanup = () => {
           if (resolved) return;
           resolved = true;
-          unsubscribeComplete();
-          unsubscribeFail();
+          for (const unsub of unsubscribes) unsub();
           if (timeoutId) {
             clearTimeout(timeoutId);
           }
         };
-        const unsubscribeComplete = eventEmitter.on("run:complete", (event) => {
-          if (event.runId === run.id && !resolved) {
-            cleanup();
-            resolve({
-              id: run.id,
-              output: event.output
-            });
-          }
-        });
-        const unsubscribeFail = eventEmitter.on("run:fail", (event) => {
-          if (event.runId === run.id && !resolved) {
-            cleanup();
-            reject(new Error(event.error));
-          }
-        });
+        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") {
@@ -148,6 +180,10 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
             cleanup();
             reject(new Error(currentRun.error || "Run failed"));
           }
+        }).catch((error) => {
+          if (resolved) return;
+          cleanup();
+          reject(error instanceof Error ? error : new Error(String(error)));
         });
         if (options?.timeout !== void 0) {
           timeoutId = setTimeout(() => {
@@ -178,6 +214,13 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
           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
@@ -222,6 +265,7 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
     name: jobDef.name,
     inputSchema,
     outputSchema,
+    labelsSchema,
     fn: jobDef.run,
     jobDef,
     handle
@@ -460,11 +504,19 @@ function createKyselyStorage(db) {
         query = query.where("durably_runs.status", "=", filter.status);
       }
       if (filter?.jobName) {
-        query = query.where("durably_runs.job_name", "=", filter.jobName);
+        if (Array.isArray(filter.jobName)) {
+          if (filter.jobName.length > 0) {
+            query = query.where("durably_runs.job_name", "in", filter.jobName);
+          }
+        } else {
+          query = query.where("durably_runs.job_name", "=", filter.jobName);
+        }
       }
       if (filter?.labels) {
-        validateLabels(filter.labels);
-        for (const [key, value] of Object.entries(filter.labels)) {
+        const labels = filter.labels;
+        validateLabels(labels);
+        for (const [key, value] of Object.entries(labels)) {
+          if (value === void 0) continue;
           query = query.where(
             sql`json_extract(durably_runs.labels, ${`$."${key}"`})`,
             "=",
@@ -526,6 +578,9 @@ function createKyselyStorage(db) {
       await db.insertInto("durably_steps").values(step).execute();
       return rowToStep(step);
     },
+    async deleteSteps(runId) {
+      await db.deleteFrom("durably_steps").where("run_id", "=", runId).execute();
+    },
     async getSteps(runId) {
       const rows = await db.selectFrom("durably_steps").selectAll().where("run_id", "=", runId).orderBy("index", "asc").execute();
       return rows.map(rowToStep);
@@ -825,6 +880,12 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
     } catch (error) {
       await handleRunFailure(run.id, run.jobName, error);
     } finally {
+      if (config.cleanupSteps) {
+        try {
+          await storage.deleteSteps(run.id);
+        } catch {
+        }
+      }
       dispose();
       if (heartbeatInterval) {
         clearInterval(heartbeatInterval);
@@ -911,10 +972,18 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
 var DEFAULTS = {
   pollingInterval: 1e3,
   heartbeatInterval: 5e3,
-  staleThreshold: 3e4
+  staleThreshold: 3e4,
+  cleanupSteps: true
 };
 function createDurablyInstance(state, jobs) {
   const { db, storage, eventEmitter, jobRegistry, worker } = state;
+  async function getRunOrThrow(runId) {
+    const run = await storage.getRun(runId);
+    if (!run) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+    return run;
+  }
   const durably = {
     db,
     storage,
@@ -933,12 +1002,16 @@ function createDurablyInstance(state, jobs) {
           jobDef,
           storage,
           eventEmitter,
-          jobRegistry
+          jobRegistry,
+          state.labelsSchema
         );
         newHandles[key] = handle;
       }
       const mergedJobs = { ...jobs, ...newHandles };
-      return createDurablyInstance(state, mergedJobs);
+      return createDurablyInstance(
+        state,
+        mergedJobs
+      );
     },
     getRun: storage.getRun,
     getRuns: storage.getRuns,
@@ -955,93 +1028,34 @@ function createDurablyInstance(state, jobs) {
     subscribe(runId) {
       let closed = false;
       let cleanup = null;
+      const closeEvents = /* @__PURE__ */ new Set(["run:complete", "run:delete"]);
+      const subscribedEvents = [
+        "run:start",
+        "run:complete",
+        "run:fail",
+        "run:cancel",
+        "run:delete",
+        "run:progress",
+        "step:start",
+        "step:complete",
+        "step:fail",
+        "log:write"
+      ];
       return new ReadableStream({
         start: (controller) => {
-          const unsubscribeStart = eventEmitter.on("run:start", (event) => {
-            if (!closed && event.runId === runId) {
+          const unsubscribes = subscribedEvents.map(
+            (type) => eventEmitter.on(type, (event) => {
+              if (closed || event.runId !== runId) return;
               controller.enqueue(event);
-            }
-          });
-          const unsubscribeComplete = eventEmitter.on(
-            "run:complete",
-            (event) => {
-              if (!closed && event.runId === runId) {
-                controller.enqueue(event);
+              if (closeEvents.has(type)) {
                 closed = true;
                 cleanup?.();
                 controller.close();
               }
-            }
-          );
-          const unsubscribeFail = eventEmitter.on("run:fail", (event) => {
-            if (!closed && event.runId === runId) {
-              controller.enqueue(event);
-            }
-          });
-          const unsubscribeCancel = eventEmitter.on("run:cancel", (event) => {
-            if (!closed && event.runId === runId) {
-              controller.enqueue(event);
-            }
-          });
-          const unsubscribeDelete = eventEmitter.on("run:delete", (event) => {
-            if (!closed && event.runId === runId) {
-              controller.enqueue(event);
-              closed = true;
-              cleanup?.();
-              controller.close();
-            }
-          });
-          const unsubscribeRetry = eventEmitter.on("run:retry", (event) => {
-            if (!closed && event.runId === runId) {
-              controller.enqueue(event);
-            }
-          });
-          const unsubscribeProgress = eventEmitter.on(
-            "run:progress",
-            (event) => {
-              if (!closed && event.runId === runId) {
-                controller.enqueue(event);
-              }
-            }
-          );
-          const unsubscribeStepStart = eventEmitter.on(
-            "step:start",
-            (event) => {
-              if (!closed && event.runId === runId) {
-                controller.enqueue(event);
-              }
-            }
-          );
-          const unsubscribeStepComplete = eventEmitter.on(
-            "step:complete",
-            (event) => {
-              if (!closed && event.runId === runId) {
-                controller.enqueue(event);
-              }
-            }
+            })
           );
-          const unsubscribeStepFail = eventEmitter.on("step:fail", (event) => {
-            if (!closed && event.runId === runId) {
-              controller.enqueue(event);
-            }
-          });
-          const unsubscribeLog = eventEmitter.on("log:write", (event) => {
-            if (!closed && event.runId === runId) {
-              controller.enqueue(event);
-            }
-          });
           cleanup = () => {
-            unsubscribeStart();
-            unsubscribeComplete();
-            unsubscribeFail();
-            unsubscribeCancel();
-            unsubscribeDelete();
-            unsubscribeRetry();
-            unsubscribeProgress();
-            unsubscribeStepStart();
-            unsubscribeStepComplete();
-            unsubscribeStepFail();
-            unsubscribeLog();
+            for (const unsub of unsubscribes) unsub();
           };
         },
         cancel: () => {
@@ -1052,36 +1066,34 @@ function createDurablyInstance(state, jobs) {
         }
       });
     },
-    async retry(runId) {
-      const run = await storage.getRun(runId);
-      if (!run) {
-        throw new Error(`Run not found: ${runId}`);
-      }
-      if (run.status === "completed") {
-        throw new Error(`Cannot retry completed run: ${runId}`);
-      }
+    async retrigger(runId) {
+      const run = await getRunOrThrow(runId);
       if (run.status === "pending") {
-        throw new Error(`Cannot retry pending run: ${runId}`);
+        throw new Error(`Cannot retrigger pending run: ${runId}`);
       }
       if (run.status === "running") {
-        throw new Error(`Cannot retry running run: ${runId}`);
+        throw new Error(`Cannot retrigger running run: ${runId}`);
       }
-      await storage.updateRun(runId, {
-        status: "pending",
-        error: null
+      if (!jobRegistry.get(run.jobName)) {
+        throw new Error(`Unknown job: ${run.jobName}`);
+      }
+      const nextRun = await storage.createRun({
+        jobName: run.jobName,
+        input: run.input,
+        concurrencyKey: run.concurrencyKey ?? void 0,
+        labels: run.labels
       });
       eventEmitter.emit({
-        type: "run:retry",
-        runId,
+        type: "run:trigger",
+        runId: nextRun.id,
         jobName: run.jobName,
+        input: run.input,
         labels: run.labels
       });
+      return nextRun;
     },
     async cancel(runId) {
-      const run = await storage.getRun(runId);
-      if (!run) {
-        throw new Error(`Run not found: ${runId}`);
-      }
+      const run = await getRunOrThrow(runId);
       if (run.status === "completed") {
         throw new Error(`Cannot cancel completed run: ${runId}`);
       }
@@ -1091,9 +1103,14 @@ function createDurablyInstance(state, jobs) {
       if (run.status === "cancelled") {
         throw new Error(`Cannot cancel already cancelled run: ${runId}`);
       }
+      const wasPending = run.status === "pending";
       await storage.updateRun(runId, {
-        status: "cancelled"
+        status: "cancelled",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
+      if (wasPending && state.cleanupSteps) {
+        await storage.deleteSteps(runId);
+      }
       eventEmitter.emit({
         type: "run:cancel",
         runId,
@@ -1102,10 +1119,7 @@ function createDurablyInstance(state, jobs) {
       });
     },
     async deleteRun(runId) {
-      const run = await storage.getRun(runId);
-      if (!run) {
-        throw new Error(`Run not found: ${runId}`);
-      }
+      const run = await getRunOrThrow(runId);
       if (run.status === "pending") {
         throw new Error(`Cannot delete pending run: ${runId}`);
       }
@@ -1145,7 +1159,8 @@ function createDurably(options) {
   const config = {
     pollingInterval: options.pollingInterval ?? DEFAULTS.pollingInterval,
     heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
-    staleThreshold: options.staleThreshold ?? DEFAULTS.staleThreshold
+    staleThreshold: options.staleThreshold ?? DEFAULTS.staleThreshold,
+    cleanupSteps: options.cleanupSteps ?? DEFAULTS.cleanupSteps
   };
   const db = new Kysely({ dialect: options.dialect });
   const storage = createKyselyStorage(db);
@@ -1158,10 +1173,19 @@ function createDurably(options) {
     eventEmitter,
     jobRegistry,
     worker,
+    labelsSchema: options.labels,
+    cleanupSteps: config.cleanupSteps,
     migrating: null,
     migrated: false
   };
-  return createDurablyInstance(state, {});
+  const instance = createDurablyInstance(
+    state,
+    {}
+  );
+  if (options.jobs) {
+    return instance.register(options.jobs);
+  }
+  return instance;
 }
 
 // src/define-job.ts
@@ -1400,6 +1424,14 @@ function createThrottledSSEController(inner, throttleMs) {
 }
 
 // src/server.ts
+var VALID_STATUSES = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+];
+var VALID_STATUSES_SET = new Set(VALID_STATUSES);
 function parseLabelsFromParams(searchParams) {
   const labels = {};
   for (const [key, value] of searchParams.entries()) {
@@ -1409,6 +1441,51 @@ function parseLabelsFromParams(searchParams) {
   }
   return Object.keys(labels).length > 0 ? labels : void 0;
 }
+function parseRunFilter(url) {
+  const jobNames = url.searchParams.getAll("jobName");
+  const statusParam = url.searchParams.get("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 limit;
+  if (limitParam) {
+    limit = Number.parseInt(limitParam, 10);
+    if (Number.isNaN(limit) || limit < 0) {
+      return errorResponse("Invalid limit: must be a non-negative integer", 400);
+    }
+  }
+  let offset;
+  if (offsetParam) {
+    offset = Number.parseInt(offsetParam, 10);
+    if (Number.isNaN(offset) || offset < 0) {
+      return errorResponse(
+        "Invalid offset: must be a non-negative integer",
+        400
+      );
+    }
+  }
+  return {
+    jobName: jobNames.length > 0 ? jobNames : void 0,
+    status: statusParam,
+    labels,
+    limit,
+    offset
+  };
+}
+function parseRunsSubscribeFilter(url) {
+  const jobNames = url.searchParams.getAll("jobName");
+  const labels = parseLabelsFromParams(url.searchParams);
+  return {
+    jobName: jobNames.length > 0 ? jobNames : void 0,
+    labels
+  };
+}
 function matchesLabels(eventLabels, filterLabels) {
   for (const [key, value] of Object.entries(filterLabels)) {
     if (eventLabels[key] !== value) return false;
@@ -1417,310 +1494,334 @@ function matchesLabels(eventLabels, filterLabels) {
 }
 function createDurablyHandler(durably, options) {
   const throttleMs = options?.sseThrottleMs ?? 100;
-  const handler = {
-    async handle(request, basePath) {
-      if (options?.onRequest) {
-        await options.onRequest();
-      }
-      const url = new URL(request.url);
-      const path = url.pathname.replace(basePath, "");
-      const method = request.method;
-      if (method === "GET") {
-        if (path === "/subscribe") return handler.subscribe(request);
-        if (path === "/runs") return handler.runs(request);
-        if (path === "/run") return handler.run(request);
-        if (path === "/steps") return handler.steps(request);
-        if (path === "/runs/subscribe") return handler.runsSubscribe(request);
+  const auth = options?.auth;
+  if (auth && !auth.authenticate) {
+    throw new Error(
+      "createDurablyHandler: auth.authenticate is required when auth is provided"
+    );
+  }
+  async function withErrorHandling(fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (error instanceof Response) throw error;
+      return errorResponse(getErrorMessage(error), 500);
+    }
+  }
+  async function requireRunAccess(url, ctx, operation) {
+    const runId = getRequiredQueryParam(url, "runId");
+    if (runId instanceof Response) return runId;
+    const run = await durably.getRun(runId);
+    if (!run) return errorResponse("Run not found", 404);
+    if (auth?.onRunAccess && ctx !== void 0) {
+      await auth.onRunAccess(ctx, run, {
+        operation
+      });
+    }
+    return { run, runId };
+  }
+  async function handleTrigger(request, ctx) {
+    return withErrorHandling(async () => {
+      const body = await request.json();
+      if (!body.jobName) {
+        return errorResponse("jobName is required", 400);
       }
-      if (method === "POST") {
-        if (path === "/trigger") return handler.trigger(request);
-        if (path === "/retry") return handler.retry(request);
-        if (path === "/cancel") return handler.cancel(request);
+      const job = durably.getJob(body.jobName);
+      if (!job) {
+        return errorResponse(`Job not found: ${body.jobName}`, 404);
       }
-      if (method === "DELETE") {
-        if (path === "/run") return handler.delete(request);
+      if (auth?.onTrigger && ctx !== void 0) {
+        await auth.onTrigger(ctx, body);
       }
-      return new Response("Not Found", { status: 404 });
-    },
-    async trigger(request) {
-      try {
-        const body = await request.json();
-        if (!body.jobName) {
-          return errorResponse("jobName is required", 400);
-        }
-        const job = durably.getJob(body.jobName);
-        if (!job) {
-          return errorResponse(`Job not found: ${body.jobName}`, 404);
-        }
-        const run = await job.trigger(body.input ?? {}, {
+      const run = await job.trigger(
+        body.input ?? {},
+        {
           idempotencyKey: body.idempotencyKey,
           concurrencyKey: body.concurrencyKey,
           labels: body.labels
-        });
-        const response = { runId: run.id };
-        return jsonResponse(response);
-      } catch (error) {
-        return errorResponse(getErrorMessage(error), 500);
-      }
-    },
-    subscribe(request) {
-      const url = new URL(request.url);
-      const runId = getRequiredQueryParam(url, "runId");
-      if (runId instanceof Response) return runId;
-      const stream = durably.subscribe(runId);
-      const sseStream = createThrottledSSEStreamFromReader(
-        stream.getReader(),
-        throttleMs
+        }
       );
-      return createSSEResponse(sseStream);
-    },
-    async runs(request) {
-      try {
-        const url = new URL(request.url);
-        const jobName = url.searchParams.get("jobName") ?? void 0;
-        const status = url.searchParams.get("status");
-        const limit = url.searchParams.get("limit");
-        const offset = url.searchParams.get("offset");
-        const labels = parseLabelsFromParams(url.searchParams);
-        const runs = await durably.getRuns({
-          jobName,
-          status,
-          labels,
-          limit: limit ? Number.parseInt(limit, 10) : void 0,
-          offset: offset ? Number.parseInt(offset, 10) : void 0
-        });
-        return jsonResponse(runs.map(toClientRun));
-      } catch (error) {
-        return errorResponse(getErrorMessage(error), 500);
+      const response = { runId: run.id };
+      return jsonResponse(response);
+    });
+  }
+  async function handleSubscribe(url, ctx) {
+    const result = await requireRunAccess(url, ctx, "subscribe");
+    if (result instanceof Response) return result;
+    const stream = durably.subscribe(result.runId);
+    const sseStream = createThrottledSSEStreamFromReader(
+      stream.getReader(),
+      throttleMs
+    );
+    return createSSEResponse(sseStream);
+  }
+  async function handleRuns(url, ctx) {
+    return withErrorHandling(async () => {
+      const filterOrError = parseRunFilter(url);
+      if (filterOrError instanceof Response) return filterOrError;
+      let filter = filterOrError;
+      if (auth?.scopeRuns && ctx !== void 0) {
+        filter = await auth.scopeRuns(ctx, filter);
       }
-    },
-    async run(request) {
-      try {
-        const url = new URL(request.url);
-        const runId = getRequiredQueryParam(url, "runId");
-        if (runId instanceof Response) return runId;
-        const run = await durably.getRun(runId);
-        if (!run) {
-          return errorResponse("Run not found", 404);
+      const runs = await durably.getRuns(filter);
+      return jsonResponse(runs.map(toClientRun));
+    });
+  }
+  async function handleRun(url, ctx) {
+    return withErrorHandling(async () => {
+      const result = await requireRunAccess(url, ctx, "read");
+      if (result instanceof Response) return result;
+      return jsonResponse(toClientRun(result.run));
+    });
+  }
+  async function handleSteps(url, ctx) {
+    return withErrorHandling(async () => {
+      const result = await requireRunAccess(url, ctx, "steps");
+      if (result instanceof Response) return result;
+      const steps = await durably.storage.getSteps(result.runId);
+      return jsonResponse(steps);
+    });
+  }
+  async function handleRetrigger(url, ctx) {
+    return withErrorHandling(async () => {
+      const result = await requireRunAccess(url, ctx, "retrigger");
+      if (result instanceof Response) return result;
+      const run = await durably.retrigger(result.runId);
+      return jsonResponse({ success: true, runId: run.id });
+    });
+  }
+  async function handleCancel(url, ctx) {
+    return withErrorHandling(async () => {
+      const result = await requireRunAccess(url, ctx, "cancel");
+      if (result instanceof Response) return result;
+      await durably.cancel(result.runId);
+      return successResponse();
+    });
+  }
+  async function handleDelete(url, ctx) {
+    return withErrorHandling(async () => {
+      const result = await requireRunAccess(url, ctx, "delete");
+      if (result instanceof Response) return result;
+      await durably.deleteRun(result.runId);
+      return successResponse();
+    });
+  }
+  async function handleRunsSubscribe(url, ctx) {
+    let filter;
+    if (ctx !== void 0 && auth?.scopeRunsSubscribe) {
+      const parsed = parseRunsSubscribeFilter(
+        url
+      );
+      filter = await auth.scopeRunsSubscribe(ctx, parsed);
+    } else if (ctx !== void 0 && auth?.scopeRuns) {
+      const parsed = parseRunsSubscribeFilter(
+        url
+      );
+      const scoped = await auth.scopeRuns(
+        ctx,
+        {
+          ...parsed
         }
-        return jsonResponse(toClientRun(run));
-      } catch (error) {
-        return errorResponse(getErrorMessage(error), 500);
-      }
-    },
-    async retry(request) {
-      try {
-        const url = new URL(request.url);
-        const runId = getRequiredQueryParam(url, "runId");
-        if (runId instanceof Response) return runId;
-        await durably.retry(runId);
-        return successResponse();
-      } catch (error) {
-        return errorResponse(getErrorMessage(error), 500);
-      }
-    },
-    async cancel(request) {
-      try {
-        const url = new URL(request.url);
-        const runId = getRequiredQueryParam(url, "runId");
-        if (runId instanceof Response) return runId;
-        await durably.cancel(runId);
-        return successResponse();
-      } catch (error) {
-        return errorResponse(getErrorMessage(error), 500);
-      }
-    },
-    async delete(request) {
-      try {
-        const url = new URL(request.url);
-        const runId = getRequiredQueryParam(url, "runId");
-        if (runId instanceof Response) return runId;
-        await durably.deleteRun(runId);
-        return successResponse();
-      } catch (error) {
-        return errorResponse(getErrorMessage(error), 500);
+      );
+      filter = { jobName: scoped.jobName, labels: scoped.labels };
+    } else {
+      filter = parseRunsSubscribeFilter(url);
+    }
+    return createRunsSSEStream(filter);
+  }
+  function createRunsSSEStream(filter) {
+    const jobNameFilter = Array.isArray(filter.jobName) ? filter.jobName : filter.jobName ? [filter.jobName] : [];
+    const labelsFilter = filter.labels;
+    const matchesFilter = (jobName, labels) => {
+      if (jobNameFilter.length > 0 && !jobNameFilter.includes(jobName))
+        return false;
+      if (labelsFilter && (!labels || !matchesLabels(labels, labelsFilter)))
+        return false;
+      return true;
+    };
+    const sseStream = createSSEStreamFromSubscriptions(
+      (innerCtrl) => {
+        const { controller: ctrl, dispose } = createThrottledSSEController(
+          innerCtrl,
+          throttleMs
+        );
+        const unsubscribes = [
+          durably.on("run:trigger", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "run:trigger",
+                runId: event.runId,
+                jobName: event.jobName,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("run:start", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "run:start",
+                runId: event.runId,
+                jobName: event.jobName,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("run:complete", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "run:complete",
+                runId: event.runId,
+                jobName: event.jobName,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("run:fail", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "run:fail",
+                runId: event.runId,
+                jobName: event.jobName,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("run:cancel", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "run:cancel",
+                runId: event.runId,
+                jobName: event.jobName,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("run:delete", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "run:delete",
+                runId: event.runId,
+                jobName: event.jobName,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("run:progress", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "run:progress",
+                runId: event.runId,
+                jobName: event.jobName,
+                progress: event.progress,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("step:start", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "step:start",
+                runId: event.runId,
+                jobName: event.jobName,
+                stepName: event.stepName,
+                stepIndex: event.stepIndex,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("step:complete", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "step:complete",
+                runId: event.runId,
+                jobName: event.jobName,
+                stepName: event.stepName,
+                stepIndex: event.stepIndex,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("step:fail", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "step:fail",
+                runId: event.runId,
+                jobName: event.jobName,
+                stepName: event.stepName,
+                stepIndex: event.stepIndex,
+                error: event.error,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("step:cancel", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "step:cancel",
+                runId: event.runId,
+                jobName: event.jobName,
+                stepName: event.stepName,
+                stepIndex: event.stepIndex,
+                labels: event.labels
+              });
+            }
+          }),
+          durably.on("log:write", (event) => {
+            if (matchesFilter(event.jobName, event.labels)) {
+              ctrl.enqueue({
+                type: "log:write",
+                runId: event.runId,
+                jobName: event.jobName,
+                labels: event.labels,
+                stepName: event.stepName,
+                level: event.level,
+                message: event.message,
+                data: event.data
+              });
+            }
+          })
+        ];
+        return [...unsubscribes, dispose];
       }
-    },
-    async steps(request) {
+    );
+    return createSSEResponse(sseStream);
+  }
+  return {
+    async handle(request, basePath) {
       try {
+        let ctx;
+        if (auth?.authenticate) {
+          ctx = await auth.authenticate(request);
+        }
+        if (options?.onRequest) {
+          await options.onRequest();
+        }
         const url = new URL(request.url);
-        const runId = getRequiredQueryParam(url, "runId");
-        if (runId instanceof Response) return runId;
-        const steps = await durably.storage.getSteps(runId);
-        return jsonResponse(steps);
+        const path = url.pathname.replace(basePath, "");
+        const method = request.method;
+        if (method === "GET") {
+          if (path === "/subscribe") return await handleSubscribe(url, ctx);
+          if (path === "/runs") return await handleRuns(url, ctx);
+          if (path === "/run") return await handleRun(url, ctx);
+          if (path === "/steps") return await handleSteps(url, ctx);
+          if (path === "/runs/subscribe")
+            return await handleRunsSubscribe(url, ctx);
+        }
+        if (method === "POST") {
+          if (path === "/trigger") return await handleTrigger(request, ctx);
+          if (path === "/retrigger") return await handleRetrigger(url, ctx);
+          if (path === "/cancel") return await handleCancel(url, ctx);
+        }
+        if (method === "DELETE") {
+          if (path === "/run") return await handleDelete(url, ctx);
+        }
+        return new Response("Not Found", { status: 404 });
       } catch (error) {
+        if (error instanceof Response) return error;
         return errorResponse(getErrorMessage(error), 500);
       }
-    },
-    runsSubscribe(request) {
-      const url = new URL(request.url);
-      const jobNameFilter = url.searchParams.get("jobName");
-      const labelsFilter = parseLabelsFromParams(url.searchParams);
-      const matchesFilter = (jobName, labels) => {
-        if (jobNameFilter && jobName !== jobNameFilter) return false;
-        if (labelsFilter && (!labels || !matchesLabels(labels, labelsFilter)))
-          return false;
-        return true;
-      };
-      const sseStream = createSSEStreamFromSubscriptions(
-        (innerCtrl) => {
-          const { controller: ctrl, dispose } = createThrottledSSEController(
-            innerCtrl,
-            throttleMs
-          );
-          const unsubscribes = [
-            durably.on("run:trigger", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "run:trigger",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("run:start", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "run:start",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("run:complete", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "run:complete",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("run:fail", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "run:fail",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("run:cancel", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "run:cancel",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("run:delete", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "run:delete",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("run:retry", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "run:retry",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("run:progress", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "run:progress",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  progress: event.progress,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("step:start", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "step:start",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  stepName: event.stepName,
-                  stepIndex: event.stepIndex,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("step:complete", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "step:complete",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  stepName: event.stepName,
-                  stepIndex: event.stepIndex,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("step:fail", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "step:fail",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  stepName: event.stepName,
-                  stepIndex: event.stepIndex,
-                  error: event.error,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("step:cancel", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "step:cancel",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  stepName: event.stepName,
-                  stepIndex: event.stepIndex,
-                  labels: event.labels
-                });
-              }
-            }),
-            durably.on("log:write", (event) => {
-              if (matchesFilter(event.jobName, event.labels)) {
-                ctrl.enqueue({
-                  type: "log:write",
-                  runId: event.runId,
-                  jobName: event.jobName,
-                  labels: event.labels,
-                  stepName: event.stepName,
-                  level: event.level,
-                  message: event.message,
-                  data: event.data
-                });
-              }
-            })
-          ];
-          return [...unsubscribes, dispose];
-        }
-      );
-      return createSSEResponse(sseStream);
     }
   };
-  return handler;
 }
 export {
   CancelledError,