@coji/durably 0.8.0 → 0.9.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) {
@@ -1164,6 +1275,21 @@ function createSSEStreamFromSubscriptions(setup) {
 }
 
 // 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 handler = {
     async handle(request, basePath) {
@@ -1202,7 +1328,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);
@@ -1227,13 +1354,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 +1376,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,112 +1428,152 @@ 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)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "run:trigger",
                 runId: event.runId,
-                jobName: event.jobName
+                jobName: event.jobName,
+                labels: event.labels
               });
             }
           }),
           durably.on("run:start", (event) => {
-            if (matchesFilter(event.jobName)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "run:start",
                 runId: event.runId,
-                jobName: event.jobName
+                jobName: event.jobName,
+                labels: event.labels
               });
             }
           }),
           durably.on("run:complete", (event) => {
-            if (matchesFilter(event.jobName)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "run:complete",
                 runId: event.runId,
-                jobName: event.jobName
+                jobName: event.jobName,
+                labels: event.labels
               });
             }
           }),
           durably.on("run:fail", (event) => {
-            if (matchesFilter(event.jobName)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "run:fail",
                 runId: event.runId,
-                jobName: event.jobName
+                jobName: event.jobName,
+                labels: event.labels
               });
             }
           }),
           durably.on("run:cancel", (event) => {
-            if (matchesFilter(event.jobName)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "run:cancel",
                 runId: event.runId,
-                jobName: event.jobName
+                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)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "run:retry",
                 runId: event.runId,
-                jobName: event.jobName
+                jobName: event.jobName,
+                labels: event.labels
               });
             }
           }),
           durably.on("run:progress", (event) => {
-            if (matchesFilter(event.jobName)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "run:progress",
                 runId: event.runId,
                 jobName: event.jobName,
-                progress: event.progress
+                progress: event.progress,
+                labels: event.labels
               });
             }
           }),
           durably.on("step:start", (event) => {
-            if (matchesFilter(event.jobName)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "step:start",
                 runId: event.runId,
                 jobName: event.jobName,
                 stepName: event.stepName,
-                stepIndex: event.stepIndex
+                stepIndex: event.stepIndex,
+                labels: event.labels
               });
             }
           }),
           durably.on("step:complete", (event) => {
-            if (matchesFilter(event.jobName)) {
+            if (matchesFilter(event.jobName, event.labels)) {
               ctrl.enqueue({
                 type: "step:complete",
                 runId: event.runId,
                 jobName: event.jobName,
                 stepName: event.stepName,
-                stepIndex: event.stepIndex
+                stepIndex: event.stepIndex,
+                labels: event.labels
               });
             }
           }),
           durably.on("step:fail", (event) => {
-            if (matchesFilter(event.jobName)) {
+            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
+                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 (!jobNameFilter) {
+            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,
@@ -1424,6 +1593,7 @@ export {
   createDurably,
   createDurablyHandler,
   defineJob,
+  toClientRun,
   withLogPersistence
 };
 //# sourceMappingURL=index.js.map