okengine 0.21.0 → 0.21.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okengine",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "description": "One law. Eight elements. One contract. The backend model stays small; operational surfaces are derived from it instead of maintained separately.",
   "license": "MIT",
   "repository": {
@@ -141,7 +141,6 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.8.0",
-    "@tanstack/react-virtual": "^3.14.11",
     "intl-messageformat": "^11.2.14",
     "oxc-parser": "^0.149.0",
     "sently": "1.2.2"
@@ -169,6 +168,7 @@
     "@tanstack/react-query": "^5.102.8",
     "@tanstack/react-router": "^1.170.34",
     "@tanstack/react-table": "^9.2.4",
+    "@tanstack/react-virtual": "^3.14.11",
     "@types/bun": "latest",
     "@types/d3-array": "^3.2.2",
     "@types/d3-shape": "^3.2.0",
@@ -194,7 +194,6 @@
     "date-fns": "^4.4.0",
     "drizzle-kit": "1.0.0-rc.5-ab785fc",
     "drizzle-orm": "1.0.0-rc.5-169397b",
-    "drizzle-seed": "^0.3.1",
     "gflows": "^1.2.1",
     "happy-dom": "^20.14.3",
     "hast-util-to-jsx-runtime": "^2.3.6",
@@ -231,7 +230,6 @@
     "ajv-formats": ">=3.0.0",
     "drizzle-kit": ">=1.0.0-rc.0",
     "drizzle-orm": ">=1.0.0-rc.0",
-    "drizzle-seed": ">=0.3.0",
     "react": ">=18.0.0",
     "zod": ">=3.23.0"
   },
@@ -275,9 +273,6 @@
     "drizzle-orm": {
       "optional": true
     },
-    "drizzle-seed": {
-      "optional": true
-    },
     "zod": {
       "optional": true
     }

package/src/cli/dev.test.ts

@@ -6,7 +6,7 @@
  * context and exercises `oke.manifest.get` over HTTP on :6535.
  */
 
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 import { mkdir, mkdtemp, readdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
@@ -17,9 +17,19 @@ import {
 } from "../compiler/generate-adopt.ts";
 import type { Manifest } from "../manifest/types.ts";
 import type { WideEvent } from "../runs/types.ts";
+import type { ConsoleAppHandle } from "../console/server/app.ts";
+import { createConsoleState } from "../console/server/state.ts";
 import { isDataEnvelope, MCP_DATA_KIND } from "../mcp/data.ts";
 import { mintMcpSession } from "../mcp/session.ts";
-import { isFlowsTreeWatchPath, runDev, type DevOptions, type DevSession } from "./dev.ts";
+import {
+  CLIENT_REGEN_DEBOUNCE_MS,
+  isClientRegenWatchPath,
+  isFlowsTreeWatchPath,
+  runDev,
+  type DevOptions,
+  type DevSession,
+  type DevWatchFn,
+} from "./dev.ts";
 import { mcpContextFromConsole } from "./mcp-from-console.ts";
 
 /** Repo public entry — absolute import so temp apps need no install. */
@@ -803,6 +813,99 @@ describe("isFlowsTreeWatchPath", () => {
   });
 });
 
+describe("isClientRegenWatchPath", () => {
+  test("flow files and schema declares regenerate the client; unrelated files do not", () => {
+    expect(isClientRegenWatchPath("flows/notes/get.ts")).toBe(true);
+    expect(isClientRegenWatchPath("schema.ts")).toBe(true);
+    expect(isClientRegenWatchPath("db/schema/links.ts")).toBe(true);
+    expect(isClientRegenWatchPath("lib/util.ts")).toBe(false);
+    expect(isClientRegenWatchPath("flows/index.ts")).toBe(false);
+    expect(isClientRegenWatchPath("flows/notes/get.ts.tmp")).toBe(false);
+    expect(isClientRegenWatchPath("db/drizzle/schema.ts")).toBe(false);
+  });
+});
+
+describe("oke dev client regen watch", () => {
+  let session: DevSession | undefined;
+
+  afterEach(() => {
+    session?.stop();
+    session = undefined;
+    mock.restore();
+  });
+
+  test("three flow saves within 50ms regenerate the client once", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-regen-"));
+    await mkdir(join(dir, "src"), { recursive: true });
+    await Bun.write(join(dir, "src/app.ts"), "export {};\n");
+
+    const extractMod = await import("../compiler/extract.ts");
+    const originalExtract = extractMod.extractManifest;
+    let extracts = 0;
+    mock.module(resolve(import.meta.dir, "../compiler/extract.ts"), () => ({
+      ...extractMod,
+      extractManifest: (opts: Parameters<typeof originalExtract>[0]) => {
+        extracts++;
+        return originalExtract(opts);
+      },
+    }));
+
+    let regens = 0;
+    let listener: Parameters<DevWatchFn>[2] | undefined;
+    const result = await runDev({
+      cwd: dir,
+      stdinIsTTY: false,
+      appPort: 0,
+      consolePort: 0,
+      mcpPort: 0,
+      ...stubSurfaces(),
+      serveConsole: async () => ({
+        port: 0,
+        stop() {},
+        console: {
+          state: createConsoleState({ cwd: dir, secret: SECRET }),
+        } as ConsoleAppHandle,
+      }),
+      startApp: async () => ({
+        port: 0,
+        url: new URL("http://127.0.0.1:9"),
+        stop() {},
+      }),
+      syncAdoptBarrel: async () => [],
+      regenClient: async () => {
+        regens++;
+      },
+      watchFs: (_path, _options, next) => {
+        listener = next;
+        return { close() {} };
+      },
+    });
+
+    expect(result.code).toBe(0);
+    session = result.session;
+    const boot = regens;
+    expect(boot).toBe(1);
+    const extractsAfterBoot = extracts;
+    expect(extractsAfterBoot).toBeGreaterThan(0);
+    if (!listener) throw new Error("watcher not started");
+
+    listener("change", "flows/notes/get.ts");
+    listener("change", "flows/notes/list.ts");
+    listener("change", "flows/notes/[id]/delete.ts");
+    await Bun.sleep(50);
+    expect(regens).toBe(boot);
+    expect(extracts).toBe(extractsAfterBoot);
+
+    await Bun.sleep(CLIENT_REGEN_DEBOUNCE_MS + 80);
+    expect(regens).toBe(boot + 1);
+    expect(extracts).toBe(extractsAfterBoot + 1);
+
+    listener("change", "lib/util.ts");
+    await Bun.sleep(CLIENT_REGEN_DEBOUNCE_MS + 80);
+    expect(regens).toBe(boot + 1);
+  });
+});
+
 describe("oke dev Docker-first", () => {
   test("dryRun always plans compose (no mode ask)", async () => {
     const dir = await mkdtemp(join(tmpdir(), "oke-dev-always-compose-"));

package/src/cli/dev.ts

@@ -1417,15 +1417,26 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
 
   const watchFs: DevWatchFn =
     options.watchFs ?? ((path, watchOptions, listener) => watch(path, watchOptions, listener));
+  // Trailing timer, always re-armed. A burst resets the window and still
+  // fires once after it goes quiet — a timestamp check that only `return`s
+  // drops the save and never regenerates.
+  const clientRegen = createDebouncedRunner(() => {
+    void regen(appUrl);
+  }, CLIENT_REGEN_DEBOUNCE_MS);
+  const manifestRefresh = createDebouncedRunner(() => {
+    void refreshManifestInto(consoleState);
+  }, CLIENT_REGEN_DEBOUNCE_MS);
   const watcher = watchFs(resolve(cwd, "src"), { recursive: true }, (_event, filename) => {
     const rel = (filename?.toString() ?? "").replace(/\\/g, "/");
     if (isFlowsTreeWatchPath(rel)) {
       void syncAdoptBarrel(cwd);
     }
-    void regen(appUrl);
+    if (isClientRegenWatchPath(rel)) {
+      clientRegen.trigger();
+    }
     // Only live-extract when the host did not pin a Manifest (tests).
     if (options.manifest === undefined) {
-      void refreshManifestInto(consoleState);
+      manifestRefresh.trigger();
     }
     if (autoPushEnabled && isDomainSchemaWatchPath(filename?.toString())) {
       lastSchemaFilename = filename?.toString() ?? "schema.ts";
@@ -1444,6 +1455,8 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     stopComposeHealthWatch = null;
     bootBoard.stop();
     autoPushRunner.cancel();
+    clientRegen.cancel();
+    manifestRefresh.cancel();
     watcher.close();
     const host = attachedHost;
     attachedHost = null;
@@ -1613,6 +1626,28 @@ export function isFlowsTreeWatchPath(rel: string): boolean {
   return true;
 }
 
+/** Quiet window before one `oke-client.d.ts` regen after a burst of saves. */
+export const CLIENT_REGEN_DEBOUNCE_MS = 200;
+
+/**
+ * True when a `src/` watcher event can change the typed client
+ * (flow files, or a schema declare module those flows import).
+ *
+ * Editor temp files and the adopt barrel are excluded so a regen cannot
+ * retrigger itself.
+ *
+ * @param rel - Watcher filename (POSIX or Windows)
+ */
+export function isClientRegenWatchPath(rel: string): boolean {
+  const posix = rel.replace(/\\/g, "/");
+  if (posix.endsWith(".tmp")) return false;
+  if (isFlowsTreeWatchPath(posix)) return true;
+  if (/(^|\/)drizzle\//.test(posix)) return false;
+  if (/(^|\/)schema(\.decl)?\.tsx?$/.test(posix)) return true;
+  if (/(^|\/)schema\/.+\.tsx?$/.test(posix)) return true;
+  return false;
+}
+
 /**
  * Frame a schema-sync failure for the `oke dev` loop: warn loud for developer
  * bugs, soft-skip only known environmental gaps. Never crashes the session.

package/src/client/create.ts

@@ -12,7 +12,7 @@
  * Untriggered flows fall back to `POST /_oke/{unit}/{flow}` RPC.
  */
 
-import { createTransport, type Transport } from "./transport.ts";
+import { createTransport, transportEnvelope, type Transport } from "./transport.ts";
 import { asThenableIterable, attachPager } from "./pager.ts";
 import {
   flattenLiveRoutes,
@@ -33,6 +33,7 @@ import type {
   LiveHandlers,
   ResolveApp,
 } from "./types.ts";
+import { methodAndPath, walkContracts } from "./wire.ts";
 
 /** App-shaped value that carries a runtime `$routes` table from typed adopt. */
 export interface AppWithRoutes {
@@ -169,19 +170,11 @@ function mergeHeaders(base: ClientHeaders | undefined, over: ClientHeaders): Cli
 export function flattenRoutes(
   $routes: ClientRouteMap | undefined,
 ): ClientOptions["routes"] | undefined {
-  if (!$routes) return undefined;
   const out: Record<string, { readonly method: string; readonly path: string }> = {};
-  for (const [unit, flows] of Object.entries($routes)) {
-    if (!flows || typeof flows !== "object") continue;
-    for (const [flow, contract] of Object.entries(flows)) {
-      if (!contract || typeof contract !== "object") continue;
-      const method = "method" in contract ? contract.method : undefined;
-      const path = "path" in contract ? contract.path : undefined;
-      if (typeof method === "string" && typeof path === "string") {
-        out[`${unit}.${flow}`] = { method, path };
-      }
-    }
-  }
+  walkContracts($routes, (unit, flow, contract) => {
+    const route = methodAndPath(contract);
+    if (route) out[`${unit}.${flow}`] = route;
+  });
   return Object.keys(out).length > 0 ? out : undefined;
 }
 
@@ -196,25 +189,19 @@ function proxy(transport: Transport, path: readonly string[], ctx: ProxyCtx): un
     if (path.length < 2) {
       const message = `Incomplete path: api.${path.join(".") || "?"}(…)`;
       return attachPager(
-        {
-          data: null,
-          error: {
-            code: "TransportError" as const,
-            message,
-            data: { message },
-          },
-        },
+        transportEnvelope(message),
         (nextInput) => invoke(nextInput, callOpts),
         input,
       );
     }
     const unit = path[0]!;
     const flow = path.slice(1).join(".");
-    const result = await transport.call(`${unit}/${flow}`, input, {
-      headers: ctx.perCallHeaders.read(),
-      ...(callOpts?.response !== undefined ? { response: callOpts.response } : {}),
-      ...(callOpts?.signal !== undefined ? { signal: callOpts.signal } : {}),
-    });
+    const headers = ctx.perCallHeaders.read();
+    const result = await transport.call(
+      `${unit}/${flow}`,
+      input,
+      callOpts ? { headers, ...callOpts } : headers,
+    );
     return attachPager(result, (nextInput) => invoke(nextInput, callOpts), input);
   };
   const call = (a?: unknown, b?: unknown): unknown => {

package/src/client/live.ts

@@ -4,7 +4,16 @@
 
 import type { ClientFetch, ClientOptions, ClientRouteMap, FlowContract } from "./types.ts";
 import type { LiveHandlers, LiveUnsubscribe } from "./types.ts";
-import { readSse, sseError } from "./sse.ts";
+import { iterateSseFrames, sseError } from "./sse.ts";
+import {
+  applyAuthHeader,
+  applyHeaderBag,
+  interpolatePath,
+  methodAndPath,
+  resolveHeaders,
+  toQuery,
+  walkContracts,
+} from "./wire.ts";
 
 /** One HTTP exposure of a live signal. */
 export interface LiveExposure {
@@ -31,24 +40,16 @@ export function flattenLiveRoutes($routes: ClientRouteMap | undefined): {
 } {
   const bySignal: Record<string, LiveExposure[]> = {};
   const byFlow: Record<string, LiveExposure> = {};
-  if (!$routes) return { bySignal, byFlow };
-  for (const [unit, flows] of Object.entries($routes)) {
-    if (!flows || typeof flows !== "object") continue;
-    for (const [flow, contract] of Object.entries(flows)) {
-      if (!contract || typeof contract !== "object") continue;
-      const live = liveName(contract);
-      const method = "method" in contract ? contract.method : undefined;
-      const path = "path" in contract ? contract.path : undefined;
-      if (typeof live !== "string" || typeof method !== "string" || typeof path !== "string") {
-        continue;
-      }
-      const matchKey = matchKeyOf(contract);
-      const id = `${unit}.${flow}`;
-      const exposure: LiveExposure = { flow: id, method, path, matchKey };
-      (bySignal[live] ??= []).push(exposure);
-      byFlow[id] = exposure;
-    }
-  }
+  walkContracts($routes, (unit, flow, contract) => {
+    const live = liveName(contract);
+    const route = methodAndPath(contract);
+    if (typeof live !== "string" || !route) return;
+    const matchKey = matchKeyOf(contract);
+    const id = `${unit}.${flow}`;
+    const exposure: LiveExposure = { flow: id, method: route.method, path: route.path, matchKey };
+    (bySignal[live] ??= []).push(exposure);
+    byFlow[id] = exposure;
+  });
   return { bySignal, byFlow };
 }
 
@@ -87,11 +88,7 @@ export function pickLiveExposure(
 ): LiveExposure {
   if (via) {
     const hit = exposures.find((e) => e.flow === via);
-    if (!hit) {
-      throw new Error(
-        `Unknown live via "${via}". Known: ${exposures.map((e) => e.flow).join(", ")}`,
-      );
-    }
+    if (!hit) throw new Error(`Unknown live via "${via}"`);
     return hit;
   }
   const keys =
@@ -100,19 +97,12 @@ export function pickLiveExposure(
       : [];
   const candidates = exposures.filter((e) => e.matchKey.every((k) => keys.includes(k)));
   if (candidates.length === 0) {
-    throw new Error(
-      `No live exposure matches input keys [${keys.join(", ")}]. Flows: ${exposures.map((e) => e.flow).join(", ")}`,
-    );
-  }
-  let max = -1;
-  for (const e of candidates) {
-    if (e.matchKey.length > max) max = e.matchKey.length;
+    throw new Error(`No live exposure matches input keys [${keys.join(", ")}]`);
   }
+  const max = Math.max(...candidates.map((e) => e.matchKey.length));
   const top = candidates.filter((e) => e.matchKey.length === max);
   if (top.length !== 1) {
-    throw new Error(
-      `Multiple live exposures match: ${top.map((e) => e.flow).join(", ")}. Pass via: "unit.flow".`,
-    );
+    throw new Error(`Multiple live exposures match. Pass via: "unit.flow".`);
   }
   return top[0]!;
 }
@@ -173,6 +163,11 @@ async function pump(
   let delayMs = LIVE_RESUBSCRIBE_INITIAL_MS;
   let attempt = 0;
   let lastSeenId: string | undefined;
+  /** Report `err`. Returns whether the loop should resubscribe. */
+  const note = (err: unknown): boolean => {
+    handlers.onError?.(err);
+    return auto;
+  };
   for (;;) {
     if (signal.aborted) return;
     if (attempt > 0 && auto) {
@@ -182,45 +177,26 @@ async function pump(
     }
     attempt += 1;
     try {
-      const res = await openSse(base, exposure, input, opts, signal, lastSeenId);
+      let res = await openSse(base, exposure, input, opts, signal, lastSeenId);
       if (signal.aborted) return;
       if (res.status === 401 && opts.auth?.refresh) {
         await opts.auth.refresh();
-        const retry = await openSse(base, exposure, input, opts, signal, lastSeenId);
-        if (signal.aborted) return;
-        lastSeenId = await consumeSse(retry, handlers, signal, lastSeenId);
+        res = await openSse(base, exposure, input, opts, signal, lastSeenId);
         if (signal.aborted) return;
-        const closed = new Error("live connection closed");
-        if (auto) {
-          handlers.onError?.(closed);
-          continue;
-        }
-        handlers.onError?.(closed);
-        return;
       }
       if (res.status === 410) {
-        const err = await liveResumeGapError(res);
         lastSeenId = undefined;
-        handlers.onError?.(err);
-        if (!auto) return;
-        continue;
+        const text = await res.text().catch(() => "");
+        if (note(sseError(410, text))) continue;
+        return;
       }
       lastSeenId = await consumeSse(res, handlers, signal, lastSeenId);
       if (signal.aborted) return;
-      const closed = new Error("live connection closed");
-      if (auto) {
-        handlers.onError?.(closed);
-        continue;
-      }
-      handlers.onError?.(closed);
+      if (note(new Error("live connection closed"))) continue;
       return;
     } catch (err) {
       if (signal.aborted) return;
-      if (auto) {
-        handlers.onError?.(err);
-        continue;
-      }
-      handlers.onError?.(err);
+      if (note(err)) continue;
       return;
     }
   }
@@ -233,23 +209,13 @@ async function consumeSse(
   lastSeenId: string | undefined,
 ): Promise<string | undefined> {
   let cursor = lastSeenId;
-  await readSse(
-    res,
-    (event, id) => {
-      handlers.onEvent(event);
-      if (id !== undefined && id.length > 0) cursor = id;
-    },
-    signal,
-    handlers.onOpen,
-  );
+  for await (const frame of iterateSseFrames(res, signal, handlers.onOpen)) {
+    handlers.onEvent(frame.event);
+    if (frame.id !== undefined && frame.id.length > 0) cursor = frame.id;
+  }
   return cursor;
 }
 
-async function liveResumeGapError(res: Response): Promise<Error> {
-  const text = await res.text().catch(() => "");
-  return sseError(410, text);
-}
-
 /**
  * Abortable delay. Resolves immediately when `signal` is already aborted.
  *
@@ -280,19 +246,8 @@ async function openSse(
 ): Promise<Response> {
   const { url, method } = restGet(base, exposure.path, input);
   const headers = new Headers({ accept: "text/event-stream" });
-  const extra = typeof opts.headers === "function" ? await opts.headers() : opts.headers;
-  if (Array.isArray(extra)) {
-    for (const [k, v] of extra) headers.set(k, v);
-  } else if (extra) {
-    for (const [k, v] of Object.entries(extra)) headers.set(k, v);
-  }
-  const token =
-    opts.auth && "getToken" in opts.auth && typeof opts.auth.getToken === "function"
-      ? await opts.auth.getToken()
-      : undefined;
-  if (token && !headers.has("authorization")) {
-    headers.set("authorization", `Bearer ${token}`);
-  }
+  applyHeaderBag(headers, await resolveHeaders(opts));
+  await applyAuthHeader(headers, opts);
   if (lastSeenId) headers.set("last-event-id", lastSeenId);
   const fetchFn: ClientFetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
   return fetchFn(url, {
@@ -304,18 +259,6 @@ async function openSse(
 }
 
 function restGet(base: string, path: string, input: unknown): { url: string; method: string } {
-  const params =
-    input !== null && typeof input === "object" ? (input as Record<string, unknown>) : {};
-  let pathOut = path;
-  const query: string[] = [];
-  for (const [k, v] of Object.entries(params)) {
-    const token = `:${k}`;
-    if (pathOut.includes(token)) {
-      pathOut = pathOut.replaceAll(token, encodeURIComponent(String(v)));
-    } else if (v !== undefined) {
-      query.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
-    }
-  }
-  const qs = query.length ? `?${query.join("&")}` : "";
-  return { url: `${base}${pathOut}${qs}`, method: "GET" };
+  const { path: pathOut, rest } = interpolatePath(path, input);
+  return { url: `${base}${pathOut}${toQuery(rest)}`, method: "GET" };
 }

package/src/client/sse.ts

@@ -4,33 +4,30 @@
  * @module
  */
 
-/** Callback for one parsed SSE data frame. */
-export type SseFrameHandler = (event: unknown, id: string | undefined) => void;
+/** One parsed SSE data frame. */
+export interface ParsedSseFrame {
+  readonly event: unknown;
+  readonly id: string | undefined;
+}
 
 /**
- * Read an SSE response body until `[DONE]`, abort, or EOF.
+ * Shared frame pump. `[DONE]` and abort end the iterator without throwing.
  *
- * @param res - Fetch response (`text/event-stream`)
- * @param onEvent - Frame handler
+ * @param res - Fetch response
  * @param signal - Abort signal
  * @param onOpen - Called after content-type validation
  */
-export async function readSse(
+export async function* iterateSseFrames(
   res: Response,
-  onEvent: SseFrameHandler,
   signal: AbortSignal,
   onOpen?: () => void,
-): Promise<void> {
+): AsyncGenerator<ParsedSseFrame> {
   if (signal.aborted) return;
   const ct = res.headers.get("content-type") ?? "";
-  if (!res.ok || !res.body) {
+  if (!res.ok || !res.body || !ct.includes("text/event-stream")) {
     const text = await res.text().catch(() => "");
     throw sseError(res.status, text);
   }
-  if (!ct.includes("text/event-stream")) {
-    const text = await res.text().catch(() => "");
-    throw sseError(res.status, text || `Expected text/event-stream, got ${ct || "none"}`);
-  }
   onOpen?.();
   const reader = res.body.getReader();
   const dec = new TextDecoder();
@@ -39,14 +36,15 @@ export async function readSse(
     for (;;) {
       if (signal.aborted) return;
       const { done, value } = await reader.read();
-      if (done) break;
+      if (done) return;
       buf += dec.decode(value, { stream: true });
       let sep = buf.indexOf("\n\n");
       while (sep >= 0) {
         const raw = buf.slice(0, sep);
         buf = buf.slice(sep + 2);
-        const stop = dispatchFrame(raw, onEvent, signal);
-        if (stop || signal.aborted) return;
+        const frame = parseFrame(raw);
+        if (frame === "done" || signal.aborted) return;
+        if (frame) yield frame;
         sep = buf.indexOf("\n\n");
       }
     }
@@ -56,65 +54,21 @@ export async function readSse(
 }
 
 /**
- * Yield SSE JSON frames as an async iterable until `[DONE]`.
+ * Parse one SSE block. `"done"` stops the pump; `null` skips empty blocks.
  *
- * @param res - Fetch response
- * @param signal - Abort signal
+ * @param raw - Text between blank lines
  */
-export async function* iterateSse(res: Response, signal: AbortSignal): AsyncGenerator<unknown> {
-  const queue: unknown[] = [];
-  let wake: (() => void) | undefined;
-  let done = false;
-  let err: unknown;
-
-  const pump = readSse(
-    res,
-    (event) => {
-      queue.push(event);
-      wake?.();
-    },
-    signal,
-  )
-    .then(() => {
-      done = true;
-      wake?.();
-    })
-    .catch((e) => {
-      err = e;
-      done = true;
-      wake?.();
-    });
-
-  try {
-    for (;;) {
-      while (queue.length > 0) {
-        yield queue.shift();
-      }
-      if (done) break;
-      await new Promise<void>((r) => {
-        wake = r;
-      });
-      wake = undefined;
-    }
-    if (err) throw err;
-  } finally {
-    await pump.catch(() => {});
-  }
-}
-
-function dispatchFrame(raw: string, onEvent: SseFrameHandler, signal: AbortSignal): boolean {
+function parseFrame(raw: string): ParsedSseFrame | "done" | null {
   const dataLines: string[] = [];
   let id: string | undefined;
   for (const line of raw.split("\n")) {
     if (line.startsWith("id:")) id = line.slice(3).replace(/^ /, "");
     if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
   }
-  if (dataLines.length === 0) return false;
+  if (dataLines.length === 0) return null;
   const data = dataLines.join("\n");
-  if (data === "[DONE]") return true;
-  if (signal.aborted) return true;
-  onEvent(JSON.parse(data) as unknown, id);
-  return false;
+  if (data === "[DONE]") return "done";
+  return { event: JSON.parse(data) as unknown, id };
 }
 
 /** Build an Error with optional HTTP status. */