@coji/durably 0.8.1 → 0.10.0

package/dist/index.js

@@ -93,15 +93,17 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
       const validatedInput = validateJobInputOrThrow(inputSchema, input);
       const run = await storage.createRun({
         jobName: jobDef.name,
-        payload: validatedInput,
+        input: validatedInput,
         idempotencyKey: options?.idempotencyKey,
-        concurrencyKey: options?.concurrencyKey
+        concurrencyKey: options?.concurrencyKey,
+        labels: options?.labels
       });
       eventEmitter.emit({
         type: "run:trigger",
         runId: run.id,
         jobName: jobDef.name,
-        payload: validatedInput
+        input: validatedInput,
+        labels: run.labels
       });
       return run;
     },
@@ -177,16 +179,17 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
           `at index ${i}`
         );
         validated.push({
-          payload: validatedInput,
+          input: validatedInput,
           options: normalized[i].options
         });
       }
       const runs = await storage.batchCreateRuns(
         validated.map((v) => ({
           jobName: jobDef.name,
-          payload: v.payload,
+          input: v.input,
           idempotencyKey: v.options?.idempotencyKey,
-          concurrencyKey: v.options?.concurrencyKey
+          concurrencyKey: v.options?.concurrencyKey,
+          labels: v.options?.labels
         }))
       );
       for (let i = 0; i < runs.length; i++) {
@@ -194,7 +197,8 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
           type: "run:trigger",
           runId: runs[i].id,
           jobName: jobDef.name,
-          payload: validated[i].payload
+          input: validated[i].input,
+          labels: runs[i].labels
         });
       }
       return runs;
@@ -230,11 +234,11 @@ var migrations = [
   {
     version: 1,
     up: async (db) => {
-      await db.schema.createTable("durably_runs").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("job_name", "text", (col) => col.notNull()).addColumn("payload", "text", (col) => col.notNull()).addColumn("status", "text", (col) => col.notNull()).addColumn("idempotency_key", "text").addColumn("concurrency_key", "text").addColumn(
+      await db.schema.createTable("durably_runs").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("job_name", "text", (col) => col.notNull()).addColumn("input", "text", (col) => col.notNull()).addColumn("status", "text", (col) => col.notNull()).addColumn("idempotency_key", "text").addColumn("concurrency_key", "text").addColumn("labels", "text", (col) => col.notNull().defaultTo("{}")).addColumn(
         "current_step_index",
         "integer",
         (col) => col.notNull().defaultTo(0)
-      ).addColumn("progress", "text").addColumn("output", "text").addColumn("error", "text").addColumn("heartbeat_at", "text", (col) => col.notNull()).addColumn("created_at", "text", (col) => col.notNull()).addColumn("updated_at", "text", (col) => col.notNull()).execute();
+      ).addColumn("progress", "text").addColumn("output", "text").addColumn("error", "text").addColumn("heartbeat_at", "text", (col) => col.notNull()).addColumn("started_at", "text").addColumn("completed_at", "text").addColumn("created_at", "text", (col) => col.notNull()).addColumn("updated_at", "text", (col) => col.notNull()).execute();
       await db.schema.createIndex("idx_durably_runs_job_idempotency").ifNotExists().on("durably_runs").columns(["job_name", "idempotency_key"]).unique().execute();
       await db.schema.createIndex("idx_durably_runs_status_concurrency").ifNotExists().on("durably_runs").columns(["status", "concurrency_key"]).execute();
       await db.schema.createIndex("idx_durably_runs_status_created").ifNotExists().on("durably_runs").columns(["status", "created_at"]).execute();
@@ -258,22 +262,47 @@ async function runMigrations(db) {
   const currentVersion = await getCurrentVersion(db);
   for (const migration of migrations) {
     if (migration.version > currentVersion) {
-      await migration.up(db);
-      await db.insertInto("durably_schema_versions").values({
-        version: migration.version,
-        applied_at: (/* @__PURE__ */ new Date()).toISOString()
-      }).execute();
+      await db.transaction().execute(async (trx) => {
+        await migration.up(trx);
+        await trx.insertInto("durably_schema_versions").values({
+          version: migration.version,
+          applied_at: (/* @__PURE__ */ new Date()).toISOString()
+        }).execute();
+      });
     }
   }
 }
 
 // src/storage.ts
-import { ulid } from "ulidx";
+import { sql } from "kysely";
+import { monotonicFactory } from "ulidx";
+var ulid = monotonicFactory();
+function toClientRun(run) {
+  const {
+    idempotencyKey,
+    concurrencyKey,
+    heartbeatAt,
+    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`
+      );
+    }
+  }
+}
 function rowToRun(row) {
   return {
     id: row.id,
     jobName: row.job_name,
-    payload: JSON.parse(row.payload),
+    input: JSON.parse(row.input),
     status: row.status,
     idempotencyKey: row.idempotency_key,
     concurrencyKey: row.concurrency_key,
@@ -282,7 +311,10 @@ function rowToRun(row) {
     progress: row.progress ? JSON.parse(row.progress) : null,
     output: row.output ? JSON.parse(row.output) : null,
     error: row.error,
+    labels: JSON.parse(row.labels),
     heartbeatAt: row.heartbeat_at,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
     createdAt: row.created_at,
     updatedAt: row.updated_at
   };
@@ -321,11 +353,12 @@ function createKyselyStorage(db) {
           return rowToRun(existing);
         }
       }
+      validateLabels(input.labels);
       const id = ulid();
       const run = {
         id,
         job_name: input.jobName,
-        payload: JSON.stringify(input.payload),
+        input: JSON.stringify(input.input),
         status: "pending",
         idempotency_key: input.idempotencyKey ?? null,
         concurrency_key: input.concurrencyKey ?? null,
@@ -333,7 +366,10 @@ function createKyselyStorage(db) {
         progress: null,
         output: null,
         error: null,
+        labels: JSON.stringify(input.labels ?? {}),
         heartbeat_at: now,
+        started_at: null,
+        completed_at: null,
         created_at: now,
         updated_at: now
       };
@@ -347,6 +383,9 @@ function createKyselyStorage(db) {
       return await db.transaction().execute(async (trx) => {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const runs = [];
+        for (const input of inputs) {
+          validateLabels(input.labels);
+        }
         for (const input of inputs) {
           if (input.idempotencyKey) {
             const existing = await trx.selectFrom("durably_runs").selectAll().where("job_name", "=", input.jobName).where("idempotency_key", "=", input.idempotencyKey).executeTakeFirst();
@@ -359,7 +398,7 @@ function createKyselyStorage(db) {
           runs.push({
             id,
             job_name: input.jobName,
-            payload: JSON.stringify(input.payload),
+            input: JSON.stringify(input.input),
             status: "pending",
             idempotency_key: input.idempotencyKey ?? null,
             concurrency_key: input.concurrencyKey ?? null,
@@ -367,7 +406,10 @@ function createKyselyStorage(db) {
             progress: null,
             output: null,
             error: null,
+            labels: JSON.stringify(input.labels ?? {}),
             heartbeat_at: now,
+            started_at: null,
+            completed_at: null,
             created_at: now,
             updated_at: now
           });
@@ -394,6 +436,9 @@ function createKyselyStorage(db) {
       if (data.error !== void 0) updates.error = data.error;
       if (data.heartbeatAt !== void 0)
         updates.heartbeat_at = data.heartbeatAt;
+      if (data.startedAt !== void 0) updates.started_at = data.startedAt;
+      if (data.completedAt !== void 0)
+        updates.completed_at = data.completedAt;
       await db.updateTable("durably_runs").set(updates).where("id", "=", runId).execute();
     },
     async deleteRun(runId) {
@@ -417,6 +462,16 @@ function createKyselyStorage(db) {
       if (filter?.jobName) {
         query = query.where("durably_runs.job_name", "=", filter.jobName);
       }
+      if (filter?.labels) {
+        validateLabels(filter.labels);
+        for (const [key, value] of Object.entries(filter.labels)) {
+          query = query.where(
+            sql`json_extract(durably_runs.labels, ${`$."${key}"`})`,
+            "=",
+            value
+          );
+        }
+      }
       query = query.orderBy("durably_runs.created_at", "desc");
       if (filter?.limit !== void 0) {
         query = query.limit(filter.limit);
@@ -430,24 +485,29 @@ function createKyselyStorage(db) {
       const rows = await query.execute();
       return rows.map(rowToRun);
     },
-    async getNextPendingRun(excludeConcurrencyKeys) {
-      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")
-      ).where("durably_runs.status", "=", "pending").groupBy("durably_runs.id").orderBy("durably_runs.created_at", "asc").orderBy("durably_runs.id", "asc").limit(1);
+    async claimNextPendingRun(excludeConcurrencyKeys) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      let subquery = db.selectFrom("durably_runs").select("id").where("status", "=", "pending").orderBy("created_at", "asc").orderBy("id", "asc").limit(1);
       if (excludeConcurrencyKeys.length > 0) {
-        query = query.where(
+        subquery = subquery.where(
           (eb) => eb.or([
-            eb("durably_runs.concurrency_key", "is", null),
-            eb(
-              "durably_runs.concurrency_key",
-              "not in",
-              excludeConcurrencyKeys
-            )
+            eb("concurrency_key", "is", null),
+            eb("concurrency_key", "not in", excludeConcurrencyKeys)
           ])
         );
       }
-      const row = await query.executeTakeFirst();
-      return row ? rowToRun(row) : null;
+      const row = await db.updateTable("durably_runs").set({
+        status: "running",
+        heartbeat_at: now,
+        started_at: sql`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 });
     },
     async createStep(input) {
       const completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -514,13 +574,26 @@ function getErrorMessage(error) {
 function createStepContext(run, jobName, storage, eventEmitter) {
   let stepIndex = run.currentStepIndex;
   let currentStepName = null;
-  return {
+  const controller = new AbortController();
+  const unsubscribe = eventEmitter.on("run:cancel", (event) => {
+    if (event.runId === run.id) {
+      controller.abort();
+    }
+  });
+  const step = {
     get runId() {
       return run.id;
     },
     async run(name, fn) {
+      if (controller.signal.aborted) {
+        throw new CancelledError(run.id);
+      }
       const currentRun = await storage.getRun(run.id);
       if (currentRun?.status === "cancelled") {
+        controller.abort();
+        throw new CancelledError(run.id);
+      }
+      if (controller.signal.aborted) {
         throw new CancelledError(run.id);
       }
       const existingStep = await storage.getCompletedStep(run.id, name);
@@ -536,10 +609,11 @@ function createStepContext(run, jobName, storage, eventEmitter) {
         runId: run.id,
         jobName,
         stepName: name,
-        stepIndex
+        stepIndex,
+        labels: run.labels
       });
       try {
-        const result = await fn();
+        const result = await fn(controller.signal);
         await storage.createStep({
           runId: run.id,
           name,
@@ -557,27 +631,32 @@ function createStepContext(run, jobName, storage, eventEmitter) {
           stepName: name,
           stepIndex: stepIndex - 1,
           output: result,
-          duration: Date.now() - startTime
+          duration: Date.now() - startTime,
+          labels: run.labels
         });
         return result;
       } catch (error) {
+        const isCancelled = controller.signal.aborted;
         const errorMessage = error instanceof Error ? error.message : String(error);
         await storage.createStep({
           runId: run.id,
           name,
           index: stepIndex,
-          status: "failed",
+          status: isCancelled ? "cancelled" : "failed",
           error: errorMessage,
           startedAt
         });
         eventEmitter.emit({
-          type: "step:fail",
+          ...isCancelled ? { type: "step:cancel" } : { type: "step:fail", error: errorMessage },
           runId: run.id,
           jobName,
           stepName: name,
           stepIndex,
-          error: errorMessage
+          labels: run.labels
         });
+        if (isCancelled) {
+          throw new CancelledError(run.id);
+        }
         throw error;
       } finally {
         currentStepName = null;
@@ -590,7 +669,8 @@ function createStepContext(run, jobName, storage, eventEmitter) {
         type: "run:progress",
         runId: run.id,
         jobName,
-        progress: progressData
+        progress: progressData,
+        labels: run.labels
       });
     },
     log: {
@@ -598,6 +678,8 @@ function createStepContext(run, jobName, storage, eventEmitter) {
         eventEmitter.emit({
           type: "log:write",
           runId: run.id,
+          jobName,
+          labels: run.labels,
           stepName: currentStepName,
           level: "info",
           message,
@@ -608,6 +690,8 @@ function createStepContext(run, jobName, storage, eventEmitter) {
         eventEmitter.emit({
           type: "log:write",
           runId: run.id,
+          jobName,
+          labels: run.labels,
           stepName: currentStepName,
           level: "warn",
           message,
@@ -618,6 +702,8 @@ function createStepContext(run, jobName, storage, eventEmitter) {
         eventEmitter.emit({
           type: "log:write",
           runId: run.id,
+          jobName,
+          labels: run.labels,
           stepName: currentStepName,
           level: "error",
           message,
@@ -626,6 +712,7 @@ function createStepContext(run, jobName, storage, eventEmitter) {
       }
     }
   };
+  return { step, dispose: unsubscribe };
 }
 
 // src/worker.ts
@@ -658,19 +745,21 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
   }
   async function handleRunSuccess(runId, jobName, output, startTime) {
     const currentRun = await storage.getRun(runId);
-    if (currentRun?.status === "cancelled") {
+    if (!currentRun || currentRun.status === "cancelled") {
       return;
     }
     await storage.updateRun(runId, {
       status: "completed",
-      output
+      output,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     eventEmitter.emit({
       type: "run:complete",
       runId,
       jobName,
       output,
-      duration: Date.now() - startTime
+      duration: Date.now() - startTime,
+      labels: currentRun.labels
     });
   }
   async function handleRunFailure(runId, jobName, error) {
@@ -678,7 +767,7 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       return;
     }
     const currentRun = await storage.getRun(runId);
-    if (currentRun?.status === "cancelled") {
+    if (!currentRun || currentRun.status === "cancelled") {
       return;
     }
     const errorMessage = getErrorMessage(error);
@@ -686,14 +775,16 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
     const failedStep = steps.find((s) => s.status === "failed");
     await storage.updateRun(runId, {
       status: "failed",
-      error: errorMessage
+      error: errorMessage,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     eventEmitter.emit({
       type: "run:fail",
       runId,
       jobName,
       error: errorMessage,
-      failedStepName: failedStep?.name ?? "unknown"
+      failedStepName: failedStep?.name ?? "unknown",
+      labels: currentRun.labels
     });
   }
   async function executeRun(run, job) {
@@ -712,12 +803,18 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       type: "run:start",
       runId: run.id,
       jobName: run.jobName,
-      payload: run.payload
+      input: run.input,
+      labels: run.labels
     });
     const startTime = Date.now();
+    const { step, dispose } = createStepContext(
+      run,
+      run.jobName,
+      storage,
+      eventEmitter
+    );
     try {
-      const step = createStepContext(run, run.jobName, storage, eventEmitter);
-      const output = await job.fn(step, run.payload);
+      const output = await job.fn(step, run.input);
       if (job.outputSchema) {
         const parseResult = job.outputSchema.safeParse(output);
         if (!parseResult.success) {
@@ -728,6 +825,7 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
     } catch (error) {
       await handleRunFailure(run.id, run.jobName, error);
     } finally {
+      dispose();
       if (heartbeatInterval) {
         clearInterval(heartbeatInterval);
         heartbeatInterval = null;
@@ -740,7 +838,7 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
     const excludeConcurrencyKeys = runningRuns.filter(
       (r) => r.concurrencyKey !== null
     ).map((r) => r.concurrencyKey);
-    const run = await storage.getNextPendingRun(excludeConcurrencyKeys);
+    const run = await storage.claimNextPendingRun(excludeConcurrencyKeys);
     if (!run) {
       return false;
     }
@@ -752,10 +850,6 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       });
       return true;
     }
-    await storage.updateRun(run.id, {
-      status: "running",
-      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
     await executeRun(run, job);
     return true;
   }
@@ -889,6 +983,14 @@ function createDurablyInstance(state, jobs) {
               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);
@@ -933,6 +1035,7 @@ function createDurablyInstance(state, jobs) {
             unsubscribeComplete();
             unsubscribeFail();
             unsubscribeCancel();
+            unsubscribeDelete();
             unsubscribeRetry();
             unsubscribeProgress();
             unsubscribeStepStart();
@@ -970,7 +1073,8 @@ function createDurablyInstance(state, jobs) {
       eventEmitter.emit({
         type: "run:retry",
         runId,
-        jobName: run.jobName
+        jobName: run.jobName,
+        labels: run.labels
       });
     },
     async cancel(runId) {
@@ -993,7 +1097,8 @@ function createDurablyInstance(state, jobs) {
       eventEmitter.emit({
         type: "run:cancel",
         runId,
-        jobName: run.jobName
+        jobName: run.jobName,
+        labels: run.labels
       });
     },
     async deleteRun(runId) {
@@ -1008,6 +1113,12 @@ function createDurablyInstance(state, jobs) {
         throw new Error(`Cannot delete running run: ${runId}`);
       }
       await storage.deleteRun(runId);
+      eventEmitter.emit({
+        type: "run:delete",
+        runId,
+        jobName: run.jobName,
+        labels: run.labels
+      });
     },
     async migrate() {
       if (state.migrated) {
@@ -1132,6 +1243,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;
@@ -1162,9 +1315,108 @@ 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
+function parseLabelsFromParams(searchParams) {
+  const labels = {};
+  for (const [key, value] of searchParams.entries()) {
+    if (key.startsWith("label.")) {
+      labels[key.slice(6)] = value;
+    }
+  }
+  return Object.keys(labels).length > 0 ? labels : void 0;
+}
+function matchesLabels(eventLabels, filterLabels) {
+  for (const [key, value] of Object.entries(filterLabels)) {
+    if (eventLabels[key] !== value) return false;
+  }
+  return true;
+}
 function createDurablyHandler(durably, options) {
+  const throttleMs = options?.sseThrottleMs ?? 100;
   const handler = {
     async handle(request, basePath) {
       if (options?.onRequest) {
@@ -1202,7 +1454,8 @@ function createDurablyHandler(durably, options) {
         }
         const run = await job.trigger(body.input ?? {}, {
           idempotencyKey: body.idempotencyKey,
-          concurrencyKey: body.concurrencyKey
+          concurrencyKey: body.concurrencyKey,
+          labels: body.labels
         });
         const response = { runId: run.id };
         return jsonResponse(response);
@@ -1215,8 +1468,9 @@ function createDurablyHandler(durably, options) {
       const runId = getRequiredQueryParam(url, "runId");
       if (runId instanceof Response) return runId;
       const stream = durably.subscribe(runId);
-      const sseStream = createSSEStreamFromReader(
-        stream.getReader()
+      const sseStream = createThrottledSSEStreamFromReader(
+        stream.getReader(),
+        throttleMs
       );
       return createSSEResponse(sseStream);
     },
@@ -1227,13 +1481,15 @@ function createDurablyHandler(durably, options) {
         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);
+        return jsonResponse(runs.map(toClientRun));
       } catch (error) {
         return errorResponse(getErrorMessage(error), 500);
       }
@@ -1247,7 +1503,7 @@ function createDurablyHandler(durably, options) {
         if (!run) {
           return errorResponse("Run not found", 404);
         }
-        return jsonResponse(run);
+        return jsonResponse(toClientRun(run));
       } catch (error) {
         return errorResponse(getErrorMessage(error), 500);
       }
@@ -1299,120 +1555,167 @@ function createDurablyHandler(durably, options) {
     runsSubscribe(request) {
       const url = new URL(request.url);
       const jobNameFilter = url.searchParams.get("jobName");
-      const matchesFilter = (jobName) => !jobNameFilter || jobName === jobNameFilter;
+      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) => [
-          durably.on("run:trigger", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "run:trigger",
-                runId: event.runId,
-                jobName: event.jobName
-              });
-            }
-          }),
-          durably.on("run:start", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "run:start",
-                runId: event.runId,
-                jobName: event.jobName
-              });
-            }
-          }),
-          durably.on("run:complete", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "run:complete",
-                runId: event.runId,
-                jobName: event.jobName
-              });
-            }
-          }),
-          durably.on("run:fail", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "run:fail",
-                runId: event.runId,
-                jobName: event.jobName
-              });
-            }
-          }),
-          durably.on("run:cancel", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "run:cancel",
-                runId: event.runId,
-                jobName: event.jobName
-              });
-            }
-          }),
-          durably.on("run:retry", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "run:retry",
-                runId: event.runId,
-                jobName: event.jobName
-              });
-            }
-          }),
-          durably.on("run:progress", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "run:progress",
-                runId: event.runId,
-                jobName: event.jobName,
-                progress: event.progress
-              });
-            }
-          }),
-          durably.on("step:start", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "step:start",
-                runId: event.runId,
-                jobName: event.jobName,
-                stepName: event.stepName,
-                stepIndex: event.stepIndex
-              });
-            }
-          }),
-          durably.on("step:complete", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "step:complete",
-                runId: event.runId,
-                jobName: event.jobName,
-                stepName: event.stepName,
-                stepIndex: event.stepIndex
-              });
-            }
-          }),
-          durably.on("step:fail", (event) => {
-            if (matchesFilter(event.jobName)) {
-              ctrl.enqueue({
-                type: "step:fail",
-                runId: event.runId,
-                jobName: event.jobName,
-                stepName: event.stepName,
-                stepIndex: event.stepIndex,
-                error: event.error
-              });
-            }
-          }),
-          durably.on("log:write", (event) => {
-            if (!jobNameFilter) {
-              ctrl.enqueue({
-                type: "log:write",
-                runId: event.runId,
-                stepName: event.stepName,
-                level: event.level,
-                message: event.message,
-                data: event.data
-              });
-            }
-          })
-        ]
+        (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);
     }
@@ -1424,6 +1727,7 @@ export {
   createDurably,
   createDurablyHandler,
   defineJob,
+  toClientRun,
   withLogPersistence
 };
 //# sourceMappingURL=index.js.map