@coji/durably 0.3.0 → 0.6.0

package/dist/index.js

@@ -51,10 +51,7 @@ function createEventEmitter() {
 function createJobRegistry() {
   const jobs = /* @__PURE__ */ new Map();
   return {
-    register(job) {
-      if (jobs.has(job.name)) {
-        throw new Error(`Job "${job.name}" is already registered`);
-      }
+    set(job) {
       jobs.set(job.name, job);
     },
     get(name) {
@@ -65,26 +62,37 @@ function createJobRegistry() {
     }
   };
 }
-function createJobHandle(definition, fn, storage, _eventEmitter, registry) {
-  registry.register({
-    name: definition.name,
-    inputSchema: definition.input,
-    outputSchema: definition.output,
-    fn
-  });
-  return {
-    name: definition.name,
+function createJobHandle(jobDef, storage, eventEmitter, registry) {
+  const existingJob = registry.get(jobDef.name);
+  if (existingJob) {
+    if (existingJob.jobDef === jobDef) {
+      return existingJob.handle;
+    }
+    throw new Error(
+      `Job "${jobDef.name}" is already registered with a different definition`
+    );
+  }
+  const inputSchema = jobDef.input;
+  const outputSchema = jobDef.output;
+  const handle = {
+    name: jobDef.name,
     async trigger(input, options) {
-      const parseResult = definition.input.safeParse(input);
+      const parseResult = inputSchema.safeParse(input);
       if (!parseResult.success) {
         throw new Error(`Invalid input: ${parseResult.error.message}`);
       }
       const run = await storage.createRun({
-        jobName: definition.name,
+        jobName: jobDef.name,
         payload: parseResult.data,
         idempotencyKey: options?.idempotencyKey,
         concurrencyKey: options?.concurrencyKey
       });
+      eventEmitter.emit({
+        type: "run:trigger",
+        runId: run.id,
+        jobName: jobDef.name,
+        payload: parseResult.data
+      });
       return run;
     },
     async triggerAndWait(input, options) {
@@ -101,19 +109,16 @@ function createJobHandle(definition, fn, 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));
@@ -156,7 +161,7 @@ function createJobHandle(definition, fn, storage, _eventEmitter, registry) {
       });
       const validated = [];
       for (let i = 0; i < normalized.length; i++) {
-        const parseResult = definition.input.safeParse(normalized[i].input);
+        const parseResult = inputSchema.safeParse(normalized[i].input);
         if (!parseResult.success) {
           throw new Error(
             `Invalid input at index ${i}: ${parseResult.error.message}`
@@ -169,17 +174,25 @@ function createJobHandle(definition, fn, storage, _eventEmitter, registry) {
       }
       const runs = await storage.batchCreateRuns(
         validated.map((v) => ({
-          jobName: definition.name,
+          jobName: jobDef.name,
           payload: v.payload,
           idempotencyKey: v.options?.idempotencyKey,
           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) {
       const run = await storage.getRun(id);
-      if (!run || run.jobName !== definition.name) {
+      if (!run || run.jobName !== jobDef.name) {
         return null;
       }
       return run;
@@ -187,11 +200,20 @@ function createJobHandle(definition, fn, storage, _eventEmitter, registry) {
     async getRuns(filter) {
       const runs = await storage.getRuns({
         ...filter,
-        jobName: definition.name
+        jobName: jobDef.name
       });
       return runs;
     }
   };
+  registry.set({
+    name: jobDef.name,
+    inputSchema,
+    outputSchema,
+    fn: jobDef.run,
+    jobDef,
+    handle
+  });
+  return handle;
 }
 
 // src/migrations.ts
@@ -247,6 +269,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,
@@ -370,18 +393,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);
       }
@@ -395,12 +422,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").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
+            )
           ])
         );
       }
@@ -536,8 +569,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: {
@@ -769,35 +807,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,
-    defineJob(definition, fn) {
-      return createJobHandle(definition, fn, 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) {
@@ -816,6 +955,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);
@@ -834,6 +978,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);
@@ -849,22 +998,58 @@ 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) {
+  return {
+    name: config.name,
+    input: config.input,
+    output: config.output,
+    run: config.run
+  };
+}
 
 // src/plugins/log-persistence.ts
 function withLogPersistence() {
@@ -883,9 +1068,444 @@ function withLogPersistence() {
     }
   };
 }
+
+// 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 new Response(
+            JSON.stringify({ error: "jobName is required" }),
+            { status: 400, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        const job = durably.getJob(body.jobName);
+        if (!job) {
+          return new Response(
+            JSON.stringify({ error: `Job not found: ${body.jobName}` }),
+            { status: 404, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        const run = await job.trigger(body.input ?? {}, {
+          idempotencyKey: body.idempotencyKey,
+          concurrencyKey: body.concurrencyKey
+        });
+        const response = { runId: run.id };
+        return new Response(JSON.stringify(response), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    },
+    subscribe(request) {
+      const url = new URL(request.url);
+      const runId = url.searchParams.get("runId");
+      if (!runId) {
+        return new Response(
+          JSON.stringify({ error: "runId query parameter is required" }),
+          { status: 400, headers: { "Content-Type": "application/json" } }
+        );
+      }
+      const stream = durably.subscribe(runId);
+      const encoder = new TextEncoder();
+      const sseStream = new ReadableStream({
+        async start(controller) {
+          const reader = stream.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                controller.close();
+                break;
+              }
+              const event = value;
+              const data = `data: ${JSON.stringify(event)}
+
+`;
+              controller.enqueue(encoder.encode(data));
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
+      return new Response(sseStream, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    },
+    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 new Response(JSON.stringify(runs), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    },
+    async run(request) {
+      try {
+        const url = new URL(request.url);
+        const runId = url.searchParams.get("runId");
+        if (!runId) {
+          return new Response(
+            JSON.stringify({ error: "runId query parameter is required" }),
+            { status: 400, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        const run = await durably.getRun(runId);
+        if (!run) {
+          return new Response(JSON.stringify({ error: "Run not found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        return new Response(JSON.stringify(run), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    },
+    async retry(request) {
+      try {
+        const url = new URL(request.url);
+        const runId = url.searchParams.get("runId");
+        if (!runId) {
+          return new Response(
+            JSON.stringify({ error: "runId query parameter is required" }),
+            { status: 400, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        await durably.retry(runId);
+        return new Response(JSON.stringify({ success: true }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    },
+    async cancel(request) {
+      try {
+        const url = new URL(request.url);
+        const runId = url.searchParams.get("runId");
+        if (!runId) {
+          return new Response(
+            JSON.stringify({ error: "runId query parameter is required" }),
+            { status: 400, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        await durably.cancel(runId);
+        return new Response(JSON.stringify({ success: true }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    },
+    async delete(request) {
+      try {
+        const url = new URL(request.url);
+        const runId = url.searchParams.get("runId");
+        if (!runId) {
+          return new Response(
+            JSON.stringify({ error: "runId query parameter is required" }),
+            { status: 400, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        await durably.deleteRun(runId);
+        return new Response(JSON.stringify({ success: true }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    },
+    async steps(request) {
+      try {
+        const url = new URL(request.url);
+        const runId = url.searchParams.get("runId");
+        if (!runId) {
+          return new Response(
+            JSON.stringify({ error: "runId query parameter is required" }),
+            { status: 400, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        const steps = await durably.storage.getSteps(runId);
+        return new Response(JSON.stringify(steps), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    },
+    runsSubscribe(request) {
+      const url = new URL(request.url);
+      const jobNameFilter = url.searchParams.get("jobName");
+      const encoder = new TextEncoder();
+      let closed = false;
+      const sseStream = new ReadableStream({
+        start(controller) {
+          const unsubscribeTrigger = durably.on("run:trigger", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "run:trigger",
+              runId: event.runId,
+              jobName: event.jobName
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeStart = durably.on("run:start", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "run:start",
+              runId: event.runId,
+              jobName: event.jobName
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeComplete = durably.on("run:complete", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "run:complete",
+              runId: event.runId,
+              jobName: event.jobName
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeFail = durably.on("run:fail", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "run:fail",
+              runId: event.runId,
+              jobName: event.jobName
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeCancel = durably.on("run:cancel", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "run:cancel",
+              runId: event.runId,
+              jobName: event.jobName
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeRetry = durably.on("run:retry", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "run:retry",
+              runId: event.runId,
+              jobName: event.jobName
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeProgress = durably.on("run:progress", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "run:progress",
+              runId: event.runId,
+              jobName: event.jobName,
+              progress: event.progress
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeStepStart = durably.on("step:start", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "step:start",
+              runId: event.runId,
+              jobName: event.jobName,
+              stepName: event.stepName,
+              stepIndex: event.stepIndex
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeStepComplete = durably.on(
+            "step:complete",
+            (event) => {
+              if (closed) return;
+              if (jobNameFilter && event.jobName !== jobNameFilter) return;
+              const data = `data: ${JSON.stringify({
+                type: "step:complete",
+                runId: event.runId,
+                jobName: event.jobName,
+                stepName: event.stepName,
+                stepIndex: event.stepIndex
+              })}
+
+`;
+              controller.enqueue(encoder.encode(data));
+            }
+          );
+          const unsubscribeStepFail = durably.on("step:fail", (event) => {
+            if (closed) return;
+            if (jobNameFilter && event.jobName !== jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "step:fail",
+              runId: event.runId,
+              jobName: event.jobName,
+              stepName: event.stepName,
+              stepIndex: event.stepIndex,
+              error: event.error
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          const unsubscribeLogWrite = durably.on("log:write", (event) => {
+            if (closed) return;
+            if (jobNameFilter) return;
+            const data = `data: ${JSON.stringify({
+              type: "log:write",
+              runId: event.runId,
+              stepName: event.stepName,
+              level: event.level,
+              message: event.message,
+              data: event.data
+            })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+          });
+          controller.cleanup = () => {
+            closed = true;
+            unsubscribeTrigger();
+            unsubscribeStart();
+            unsubscribeComplete();
+            unsubscribeFail();
+            unsubscribeCancel();
+            unsubscribeRetry();
+            unsubscribeProgress();
+            unsubscribeStepStart();
+            unsubscribeStepComplete();
+            unsubscribeStepFail();
+            unsubscribeLogWrite();
+          };
+        },
+        cancel(controller) {
+          const cleanup = controller.cleanup;
+          if (cleanup) cleanup();
+        }
+      });
+      return new Response(sseStream, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    }
+  };
+  return handler;
+}
 export {
   CancelledError,
   createDurably,
+  createDurablyHandler,
+  defineJob,
   withLogPersistence
 };
 //# sourceMappingURL=index.js.map