@coji/durably 0.4.0 → 0.6.1

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  withLogPersistence
+} from "./chunk-UCUP6NMJ.js";
+
 // src/durably.ts
 import { Kysely } from "kysely";
 
@@ -48,6 +52,15 @@ function createEventEmitter() {
 }
 
 // src/job.ts
+import { prettifyError } from "zod";
+function validateJobInputOrThrow(schema, input, context) {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const prefix = context ? `${context}: ` : "";
+    throw new Error(`${prefix}Invalid input: ${prettifyError(result.error)}`);
+  }
+  return result.data;
+}
 function createJobRegistry() {
   const jobs = /* @__PURE__ */ new Map();
   return {
@@ -62,7 +75,7 @@ function createJobRegistry() {
     }
   };
 }
-function createJobHandle(jobDef, storage, _eventEmitter, registry) {
+function createJobHandle(jobDef, storage, eventEmitter, registry) {
   const existingJob = registry.get(jobDef.name);
   if (existingJob) {
     if (existingJob.jobDef === jobDef) {
@@ -77,16 +90,19 @@ function createJobHandle(jobDef, storage, _eventEmitter, registry) {
   const handle = {
     name: jobDef.name,
     async trigger(input, options) {
-      const parseResult = inputSchema.safeParse(input);
-      if (!parseResult.success) {
-        throw new Error(`Invalid input: ${parseResult.error.message}`);
-      }
+      const validatedInput = validateJobInputOrThrow(inputSchema, input);
       const run = await storage.createRun({
         jobName: jobDef.name,
-        payload: parseResult.data,
+        payload: validatedInput,
         idempotencyKey: options?.idempotencyKey,
         concurrencyKey: options?.concurrencyKey
       });
+      eventEmitter.emit({
+        type: "run:trigger",
+        runId: run.id,
+        jobName: jobDef.name,
+        payload: validatedInput
+      });
       return run;
     },
     async triggerAndWait(input, options) {
@@ -103,19 +119,16 @@ function createJobHandle(jobDef, storage, _eventEmitter, registry) {
             clearTimeout(timeoutId);
           }
         };
-        const unsubscribeComplete = _eventEmitter.on(
-          "run:complete",
-          (event) => {
-            if (event.runId === run.id && !resolved) {
-              cleanup();
-              resolve({
-                id: run.id,
-                output: event.output
-              });
-            }
+        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) => {
+        });
+        const unsubscribeFail = eventEmitter.on("run:fail", (event) => {
           if (event.runId === run.id && !resolved) {
             cleanup();
             reject(new Error(event.error));
@@ -158,14 +171,13 @@ function createJobHandle(jobDef, storage, _eventEmitter, registry) {
       });
       const validated = [];
       for (let i = 0; i < normalized.length; i++) {
-        const parseResult = inputSchema.safeParse(normalized[i].input);
-        if (!parseResult.success) {
-          throw new Error(
-            `Invalid input at index ${i}: ${parseResult.error.message}`
-          );
-        }
+        const validatedInput = validateJobInputOrThrow(
+          inputSchema,
+          normalized[i].input,
+          `at index ${i}`
+        );
         validated.push({
-          payload: parseResult.data,
+          payload: validatedInput,
           options: normalized[i].options
         });
       }
@@ -177,6 +189,14 @@ function createJobHandle(jobDef, storage, _eventEmitter, registry) {
           concurrencyKey: v.options?.concurrencyKey
         }))
       );
+      for (let i = 0; i < runs.length; i++) {
+        eventEmitter.emit({
+          type: "run:trigger",
+          runId: runs[i].id,
+          jobName: jobDef.name,
+          payload: validated[i].payload
+        });
+      }
       return runs;
     },
     async getRun(id) {
@@ -258,6 +278,7 @@ function rowToRun(row) {
     idempotencyKey: row.idempotency_key,
     concurrencyKey: row.concurrency_key,
     currentStepIndex: row.current_step_index,
+    stepCount: Number(row.step_count ?? 0),
     progress: row.progress ? JSON.parse(row.progress) : null,
     output: row.output ? JSON.parse(row.output) : null,
     error: row.error,
@@ -381,18 +402,22 @@ function createKyselyStorage(db) {
       await db.deleteFrom("durably_runs").where("id", "=", runId).execute();
     },
     async getRun(runId) {
-      const row = await db.selectFrom("durably_runs").selectAll().where("id", "=", runId).executeTakeFirst();
+      const row = await db.selectFrom("durably_runs").leftJoin("durably_steps", "durably_runs.id", "durably_steps.run_id").selectAll("durably_runs").select(
+        (eb) => eb.fn.count("durably_steps.id").as("step_count")
+      ).where("durably_runs.id", "=", runId).groupBy("durably_runs.id").executeTakeFirst();
       return row ? rowToRun(row) : null;
     },
     async getRuns(filter) {
-      let query = db.selectFrom("durably_runs").selectAll();
+      let query = db.selectFrom("durably_runs").leftJoin("durably_steps", "durably_runs.id", "durably_steps.run_id").selectAll("durably_runs").select(
+        (eb) => eb.fn.count("durably_steps.id").as("step_count")
+      ).groupBy("durably_runs.id");
       if (filter?.status) {
-        query = query.where("status", "=", filter.status);
+        query = query.where("durably_runs.status", "=", filter.status);
       }
       if (filter?.jobName) {
-        query = query.where("job_name", "=", filter.jobName);
+        query = query.where("durably_runs.job_name", "=", filter.jobName);
       }
-      query = query.orderBy("created_at", "desc");
+      query = query.orderBy("durably_runs.created_at", "desc");
       if (filter?.limit !== void 0) {
         query = query.limit(filter.limit);
       }
@@ -406,12 +431,18 @@ function createKyselyStorage(db) {
       return rows.map(rowToRun);
     },
     async getNextPendingRun(excludeConcurrencyKeys) {
-      let query = db.selectFrom("durably_runs").selectAll().where("status", "=", "pending").orderBy("created_at", "asc").limit(1);
+      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);
       if (excludeConcurrencyKeys.length > 0) {
         query = query.where(
           (eb) => eb.or([
-            eb("concurrency_key", "is", null),
-            eb("concurrency_key", "not in", excludeConcurrencyKeys)
+            eb("durably_runs.concurrency_key", "is", null),
+            eb(
+              "durably_runs.concurrency_key",
+              "not in",
+              excludeConcurrencyKeys
+            )
           ])
         );
       }
@@ -465,6 +496,9 @@ function createKyselyStorage(db) {
   };
 }
 
+// src/worker.ts
+import { prettifyError as prettifyError2 } from "zod";
+
 // src/errors.ts
 var CancelledError = class extends Error {
   constructor(runId) {
@@ -472,6 +506,9 @@ var CancelledError = class extends Error {
     this.name = "CancelledError";
   }
 };
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/context.ts
 function createStepContext(run, jobName, storage, eventEmitter) {
@@ -547,8 +584,13 @@ function createStepContext(run, jobName, storage, eventEmitter) {
       }
     },
     progress(current, total, message) {
-      storage.updateRun(run.id, {
-        progress: { current, total, message }
+      const progressData = { current, total, message };
+      storage.updateRun(run.id, { progress: progressData });
+      eventEmitter.emit({
+        type: "run:progress",
+        runId: run.id,
+        jobName,
+        progress: progressData
       });
     },
     log: {
@@ -614,9 +656,6 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       });
     }
   }
-  function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-  }
   async function handleRunSuccess(runId, jobName, output, startTime) {
     const currentRun = await storage.getRun(runId);
     if (currentRun?.status === "cancelled") {
@@ -663,7 +702,7 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       updateHeartbeat().catch((error) => {
         eventEmitter.emit({
           type: "worker:error",
-          error: error instanceof Error ? error.message : String(error),
+          error: getErrorMessage(error),
           context: "heartbeat",
           runId: run.id
         });
@@ -682,7 +721,7 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       if (job.outputSchema) {
         const parseResult = job.outputSchema.safeParse(output);
         if (!parseResult.success) {
-          throw new Error(`Invalid output: ${parseResult.error.message}`);
+          throw new Error(`Invalid output: ${prettifyError2(parseResult.error)}`);
         }
       }
       await handleRunSuccess(run.id, run.jobName, output, startTime);
@@ -780,35 +819,136 @@ var DEFAULTS = {
   heartbeatInterval: 5e3,
   staleThreshold: 3e4
 };
-function createDurably(options) {
-  const config = {
-    pollingInterval: options.pollingInterval ?? DEFAULTS.pollingInterval,
-    heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
-    staleThreshold: options.staleThreshold ?? DEFAULTS.staleThreshold
-  };
-  const db = new Kysely({ dialect: options.dialect });
-  const storage = createKyselyStorage(db);
-  const eventEmitter = createEventEmitter();
-  const jobRegistry = createJobRegistry();
-  const worker = createWorker(config, storage, eventEmitter, jobRegistry);
-  let migrating = null;
-  let migrated = false;
+function createDurablyInstance(state, jobs) {
+  const { db, storage, eventEmitter, jobRegistry, worker } = state;
   const durably = {
     db,
     storage,
+    jobs,
     on: eventEmitter.on,
     emit: eventEmitter.emit,
     onError: eventEmitter.onError,
     start: worker.start,
     stop: worker.stop,
-    register(jobDef) {
-      return createJobHandle(jobDef, storage, eventEmitter, jobRegistry);
+    // biome-ignore lint/suspicious/noExplicitAny: flexible type constraint for job definitions
+    register(jobDefs) {
+      const newHandles = {};
+      for (const key of Object.keys(jobDefs)) {
+        const jobDef = jobDefs[key];
+        const handle = createJobHandle(
+          jobDef,
+          storage,
+          eventEmitter,
+          jobRegistry
+        );
+        newHandles[key] = handle;
+      }
+      const mergedJobs = { ...jobs, ...newHandles };
+      return createDurablyInstance(state, mergedJobs);
     },
     getRun: storage.getRun,
     getRuns: storage.getRuns,
     use(plugin) {
       plugin.install(durably);
     },
+    getJob(name) {
+      const registeredJob = jobRegistry.get(name);
+      if (!registeredJob) {
+        return void 0;
+      }
+      return registeredJob.handle;
+    },
+    subscribe(runId) {
+      let closed = false;
+      let cleanup = null;
+      return new ReadableStream({
+        start: (controller) => {
+          const unsubscribeStart = eventEmitter.on("run:start", (event) => {
+            if (!closed && event.runId === runId) {
+              controller.enqueue(event);
+            }
+          });
+          const unsubscribeComplete = eventEmitter.on(
+            "run:complete",
+            (event) => {
+              if (!closed && event.runId === runId) {
+                controller.enqueue(event);
+                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 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();
+            unsubscribeRetry();
+            unsubscribeProgress();
+            unsubscribeStepStart();
+            unsubscribeStepComplete();
+            unsubscribeStepFail();
+            unsubscribeLog();
+          };
+        },
+        cancel: () => {
+          if (!closed) {
+            closed = true;
+            cleanup?.();
+          }
+        }
+      });
+    },
     async retry(runId) {
       const run = await storage.getRun(runId);
       if (!run) {
@@ -827,6 +967,11 @@ function createDurably(options) {
         status: "pending",
         error: null
       });
+      eventEmitter.emit({
+        type: "run:retry",
+        runId,
+        jobName: run.jobName
+      });
     },
     async cancel(runId) {
       const run = await storage.getRun(runId);
@@ -845,6 +990,11 @@ function createDurably(options) {
       await storage.updateRun(runId, {
         status: "cancelled"
       });
+      eventEmitter.emit({
+        type: "run:cancel",
+        runId,
+        jobName: run.jobName
+      });
     },
     async deleteRun(runId) {
       const run = await storage.getRun(runId);
@@ -860,22 +1010,48 @@ function createDurably(options) {
       await storage.deleteRun(runId);
     },
     async migrate() {
-      if (migrated) {
+      if (state.migrated) {
         return;
       }
-      if (migrating) {
-        return migrating;
+      if (state.migrating) {
+        return state.migrating;
       }
-      migrating = runMigrations(db).then(() => {
-        migrated = true;
+      state.migrating = runMigrations(db).then(() => {
+        state.migrated = true;
       }).finally(() => {
-        migrating = null;
+        state.migrating = null;
       });
-      return migrating;
+      return state.migrating;
+    },
+    async init() {
+      await this.migrate();
+      this.start();
     }
   };
   return durably;
 }
+function createDurably(options) {
+  const config = {
+    pollingInterval: options.pollingInterval ?? DEFAULTS.pollingInterval,
+    heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
+    staleThreshold: options.staleThreshold ?? DEFAULTS.staleThreshold
+  };
+  const db = new Kysely({ dialect: options.dialect });
+  const storage = createKyselyStorage(db);
+  const eventEmitter = createEventEmitter();
+  const jobRegistry = createJobRegistry();
+  const worker = createWorker(config, storage, eventEmitter, jobRegistry);
+  const state = {
+    db,
+    storage,
+    eventEmitter,
+    jobRegistry,
+    worker,
+    migrating: null,
+    migrated: false
+  };
+  return createDurablyInstance(state, {});
+}
 
 // src/define-job.ts
 function defineJob(config) {
@@ -887,26 +1063,366 @@ function defineJob(config) {
   };
 }
 
-// src/plugins/log-persistence.ts
-function withLogPersistence() {
-  return {
-    name: "log-persistence",
-    install(durably) {
-      durably.on("log:write", async (event) => {
-        await durably.storage.createLog({
-          runId: event.runId,
-          stepName: event.stepName,
-          level: event.level,
-          message: event.message,
-          data: event.data
+// src/http.ts
+var JSON_HEADERS = {
+  "Content-Type": "application/json"
+};
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: JSON_HEADERS
+  });
+}
+function errorResponse(message, status = 500) {
+  return jsonResponse({ error: message }, status);
+}
+function successResponse() {
+  return jsonResponse({ success: true });
+}
+function getRequiredQueryParam(url, paramName) {
+  const value = url.searchParams.get(paramName);
+  if (!value) {
+    return errorResponse(`${paramName} query parameter is required`, 400);
+  }
+  return value;
+}
+
+// src/sse.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive"
+};
+function formatSSE(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function createSSEEncoder() {
+  return new TextEncoder();
+}
+function encodeSSE(encoder, data) {
+  return encoder.encode(formatSSE(data));
+}
+function createSSEResponse(stream) {
+  return new Response(stream, {
+    status: 200,
+    headers: SSE_HEADERS
+  });
+}
+function createSSEStreamFromReader(reader) {
+  const encoder = createSSEEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            break;
+          }
+          controller.enqueue(encodeSSE(encoder, value));
+        }
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel() {
+      reader.releaseLock();
+    }
+  });
+}
+function createSSEStreamFromSubscriptions(setup) {
+  const encoder = createSSEEncoder();
+  let closed = false;
+  let unsubscribes = [];
+  return new ReadableStream({
+    start(controller) {
+      const sseController = {
+        enqueue: (data) => {
+          if (closed) return;
+          controller.enqueue(encodeSSE(encoder, data));
+        },
+        close: () => {
+          if (closed) return;
+          closed = true;
+          controller.close();
+        },
+        get closed() {
+          return closed;
+        }
+      };
+      unsubscribes = setup(sseController);
+    },
+    cancel() {
+      closed = true;
+      for (const unsubscribe of unsubscribes) {
+        unsubscribe();
+      }
+    }
+  });
+}
+
+// src/server.ts
+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);
+      }
+      if (method === "POST") {
+        if (path === "/trigger") return handler.trigger(request);
+        if (path === "/retry") return handler.retry(request);
+        if (path === "/cancel") return handler.cancel(request);
+      }
+      if (method === "DELETE") {
+        if (path === "/run") return handler.delete(request);
+      }
+      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 ?? {}, {
+          idempotencyKey: body.idempotencyKey,
+          concurrencyKey: body.concurrencyKey
         });
-      });
+        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 runs = await durably.getRuns({
+          jobName,
+          status,
+          limit: limit ? Number.parseInt(limit, 10) : void 0,
+          offset: offset ? Number.parseInt(offset, 10) : void 0
+        });
+        return jsonResponse(runs);
+      } catch (error) {
+        return errorResponse(getErrorMessage(error), 500);
+      }
+    },
+    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);
+        }
+        return jsonResponse(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 matchesFilter = (jobName) => !jobNameFilter || jobName === jobNameFilter;
+      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
+              });
+            }
+          })
+        ]
+      );
+      return createSSEResponse(sseStream);
     }
   };
+  return handler;
 }
 export {
   CancelledError,
   createDurably,
+  createDurablyHandler,
   defineJob,
   withLogPersistence
 };