@coji/durably 0.9.0 → 0.11.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}"`})`,
             "=",
@@ -933,12 +985,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 +1011,35 @@ 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:retry",
+        "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: () => {
@@ -1158,10 +1156,18 @@ function createDurably(options) {
     eventEmitter,
     jobRegistry,
     worker,
+    labelsSchema: options.labels,
     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
@@ -1243,6 +1249,48 @@ function createSSEStreamFromReader(reader) {
     }
   });
 }
+function createThrottledSSEStreamFromReader(reader, throttleMs) {
+  if (throttleMs <= 0) {
+    return createSSEStreamFromReader(reader);
+  }
+  const encoder = createSSEEncoder();
+  let closed = false;
+  let throttle = null;
+  return new ReadableStream({
+    async start(controller) {
+      const innerCtrl = {
+        enqueue: (data) => controller.enqueue(encodeSSE(encoder, data)),
+        close: () => {
+          closed = true;
+          controller.close();
+        },
+        get closed() {
+          return closed;
+        }
+      };
+      throttle = createThrottledSSEController(innerCtrl, throttleMs);
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            throttle.controller.close();
+            break;
+          }
+          throttle.controller.enqueue(value);
+        }
+      } catch (error) {
+        throttle.dispose();
+        reader.releaseLock();
+        controller.error(error);
+      }
+    },
+    cancel() {
+      closed = true;
+      throttle?.dispose();
+      reader.releaseLock();
+    }
+  });
+}
 function createSSEStreamFromSubscriptions(setup) {
   const encoder = createSSEEncoder();
   let closed = false;
@@ -1273,8 +1321,99 @@ function createSSEStreamFromSubscriptions(setup) {
     }
   });
 }
+var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "run:complete",
+  "run:fail",
+  "run:cancel",
+  "run:delete"
+]);
+function createThrottledSSEController(inner, throttleMs) {
+  if (throttleMs <= 0) {
+    return { controller: inner, dispose: () => {
+    } };
+  }
+  const pending = /* @__PURE__ */ new Map();
+  const lastSent = /* @__PURE__ */ new Map();
+  const controller = {
+    enqueue(data) {
+      if (inner.closed) return;
+      const event = typeof data === "object" && data !== null ? data : null;
+      if (event?.runId && TERMINAL_EVENT_TYPES.has(event.type ?? "")) {
+        lastSent.delete(event.runId);
+        const entry = pending.get(event.runId);
+        if (entry) {
+          clearTimeout(entry.timer);
+          if (!inner.closed) inner.enqueue(entry.data);
+          pending.delete(event.runId);
+        }
+      }
+      if (event?.type !== "run:progress" || !event?.runId) {
+        inner.enqueue(data);
+        return;
+      }
+      const runId = event.runId;
+      const now = Date.now();
+      const last = lastSent.get(runId) ?? 0;
+      if (now - last >= throttleMs) {
+        lastSent.set(runId, now);
+        const entry = pending.get(runId);
+        if (entry) {
+          clearTimeout(entry.timer);
+          pending.delete(runId);
+        }
+        inner.enqueue(data);
+        return;
+      }
+      const existing = pending.get(runId);
+      if (existing) {
+        clearTimeout(existing.timer);
+      }
+      const delay = Math.max(0, throttleMs - (now - last));
+      const timer = setTimeout(() => {
+        const current = pending.get(runId);
+        if (!current || current.timer !== timer) return;
+        pending.delete(runId);
+        if (!inner.closed) {
+          lastSent.set(runId, Date.now());
+          inner.enqueue(current.data);
+        }
+      }, delay);
+      pending.set(runId, { data, timer });
+    },
+    close() {
+      for (const [, entry] of pending) {
+        clearTimeout(entry.timer);
+        if (!inner.closed) {
+          inner.enqueue(entry.data);
+        }
+      }
+      pending.clear();
+      lastSent.clear();
+      inner.close();
+    },
+    get closed() {
+      return inner.closed;
+    }
+  };
+  const dispose = () => {
+    for (const [, entry] of pending) {
+      clearTimeout(entry.timer);
+    }
+    pending.clear();
+    lastSent.clear();
+  };
+  return { controller, dispose };
+}
 
 // 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()) {
@@ -1284,6 +1423,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;
@@ -1291,152 +1475,159 @@ function matchesLabels(eventLabels, filterLabels) {
   return true;
 }
 function createDurablyHandler(durably, options) {
-  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 throttleMs = options?.sseThrottleMs ?? 100;
+  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 = createSSEStreamFromReader(
-        stream.getReader()
+        }
       );
-      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 handleRetry(url, ctx) {
+    return withErrorHandling(async () => {
+      const result = await requireRunAccess(url, ctx, "retry");
+      if (result instanceof Response) return result;
+      await durably.retry(result.runId);
+      return successResponse();
+    });
+  }
+  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);
-      }
-    },
-    async steps(request) {
-      try {
-        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);
-      } catch (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(
-        (ctrl) => [
+      );
+      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({
@@ -1581,12 +1772,48 @@ function createDurablyHandler(durably, options) {
               });
             }
           })
-        ]
-      );
-      return createSSEResponse(sseStream);
+        ];
+        return [...unsubscribes, dispose];
+      }
+    );
+    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 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 === "/retry") return await handleRetry(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);
+      }
     }
   };
-  return handler;
 }
 export {
   CancelledError,