@coji/durably 0.4.0 → 0.6.0

package/dist/index.js

@@ -62,7 +62,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) {
@@ -87,6 +87,12 @@ function createJobHandle(jobDef, storage, _eventEmitter, registry) {
         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) {
@@ -103,19 +109,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));
@@ -177,6 +180,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 +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,
@@ -381,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);
       }
@@ -406,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
+            )
           ])
         );
       }
@@ -547,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: {
@@ -780,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,
-    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 +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);
@@ -845,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);
@@ -860,22 +998,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) {
@@ -904,9 +1068,443 @@ 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
 };