@cosmicdrift/kumiko-dispatcher-live 0.165.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dispatcher-live",
-  "version": "0.165.0",
+  "version": "2.0.0",
   "description": "HTTP-only Dispatcher for Kumiko UIs. Always-online; failures surface immediately. Default client for web admin/cockpit apps.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -24,7 +24,7 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-headless": "0.165.0"
+    "@cosmicdrift/kumiko-headless": "2.0.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/__tests__/sse-stream.test.ts

@@ -74,4 +74,56 @@ describe("iterateSseChunks", () => {
       }
     }).toThrow(/nope/);
   });
+
+  test("stream closed without a done frame throws instead of ending cleanly", async () => {
+    const text = ["event: chunk", 'data: {"i":0}', ""].join("\n");
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(text));
+        controller.close();
+      },
+    });
+
+    const chunks: unknown[] = [];
+    await expect(async () => {
+      for await (const c of iterateSseChunks(stream)) chunks.push(c);
+    }).toThrow(/without a done frame/);
+    expect(chunks).toEqual([{ i: 0 }]);
+  });
+
+  test("malformed chunk JSON throws a DispatcherError instead of a raw SyntaxError", async () => {
+    const text = ["event: chunk", "data: {not json", "", "event: done", "data: ", ""].join("\n");
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(text));
+        controller.close();
+      },
+    });
+
+    await expect(async () => {
+      for await (const _ of iterateSseChunks(stream)) {
+        // no chunks expected
+      }
+    }).toThrow(/malformed chunk frame/);
+  });
+
+  test("cancels the reader on early break instead of leaving the response open", async () => {
+    let cancelled = false;
+    const text = ["event: chunk", 'data: {"i":0}', "", "event: chunk", 'data: {"i":1}', ""].join(
+      "\n",
+    );
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(text));
+      },
+      cancel() {
+        cancelled = true;
+      },
+    });
+
+    for await (const _ of iterateSseChunks(stream)) {
+      break;
+    }
+    expect(cancelled).toBe(true);
+  });
 });

package/src/dispatcher-live.ts

@@ -257,6 +257,7 @@ export function createLiveDispatcher(options: LiveDispatcherOptions = {}): Dispa
         // body — both must map to the same `aborted` envelope so hooks
         // (useStreamHandler) can ignore user-cancel without an error toast.
         if (isAbortError(e) || opts?.signal?.aborted) throw buildAbortError();
+        observeNetworkOutcome(false);
         throw e;
       }
     },

package/src/index.ts

@@ -2,3 +2,5 @@ export { CSRF_COOKIE_NAME, CSRF_HEADER_NAME, readCsrfToken } from "./csrf";
 export type { LiveDispatcherOptions } from "./dispatcher-live";
 export { createLiveDispatcher } from "./dispatcher-live";
 export { buildAbortError, buildNetworkError, mapServerError } from "./error-mapping";
+export type { SseFrame } from "./sse-stream";
+export { iterateSseChunks, parseSseBlock, parseSseFrames } from "./sse-stream";

package/src/sse-stream.ts

@@ -1,4 +1,4 @@
-import type { DispatcherError } from "@cosmicdrift/kumiko-headless";
+import { type DispatcherError, StreamFrame } from "@cosmicdrift/kumiko-headless";
 import { mapServerError } from "./error-mapping";
 
 // Parse the SSE wire format produced by Hono `streamSSE` for POST /api/stream:
@@ -41,6 +41,7 @@ export async function* iterateSseChunks<TChunk>(
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
+  let sawDone = false;
   try {
     while (true) {
       const { done, value } = await reader.read();
@@ -51,29 +52,64 @@ export async function* iterateSseChunks<TChunk>(
       for (const part of parts) {
         const frame = parseSseBlock(part);
         if (frame === null) continue;
-        if (frame.event === "ping") continue;
+        if (frame.event === StreamFrame.ping) continue;
         // skip: terminal SSE done frame — end the generator cleanly
-        if (frame.event === "done") return;
-        if (frame.event === "error") {
+        if (frame.event === StreamFrame.done) {
+          sawDone = true;
+          return;
+        }
+        if (frame.event === StreamFrame.error) {
           throw frameDataToDispatcherError(frame.data);
         }
-        if (frame.event === "chunk") {
-          yield JSON.parse(frame.data) as TChunk;
+        if (frame.event === StreamFrame.chunk) {
+          yield parseChunkData<TChunk>(frame.data);
         }
       }
     }
     // Trailing buffer without final blank line (some runtimes).
     const frame = parseSseBlock(buffer);
-    if (frame?.event === "chunk") {
-      yield JSON.parse(frame.data) as TChunk;
-    } else if (frame?.event === "error") {
+    if (frame?.event === StreamFrame.chunk) {
+      yield parseChunkData<TChunk>(frame.data);
+    } else if (frame?.event === StreamFrame.error) {
       throw frameDataToDispatcherError(frame.data);
+    } else if (frame?.event === StreamFrame.done) {
+      sawDone = true;
+    }
+    if (!sawDone) {
+      throw buildTruncatedStreamError();
     }
   } finally {
-    reader.releaseLock();
+    // cancel() releases the reader's lock too (safe on an already-drained
+    // stream) and, unlike releaseLock() alone, tells the underlying HTTP
+    // response to close instead of leaving the connection open until the
+    // server finishes writing a body no one is reading anymore.
+    await reader.cancel().catch(() => {});
   }
 }
 
+function parseChunkData<TChunk>(data: string): TChunk {
+  try {
+    return JSON.parse(data) as TChunk;
+  } catch (e) {
+    const cause = e instanceof Error ? e.message : String(e);
+    throw {
+      code: "stream_error",
+      httpStatus: 200,
+      i18nKey: "errors.unknown",
+      message: `malformed chunk frame: ${cause}`,
+    } satisfies DispatcherError;
+  }
+}
+
+function buildTruncatedStreamError(): DispatcherError {
+  return {
+    code: "stream_error",
+    httpStatus: 200,
+    i18nKey: "errors.unknown",
+    message: "stream ended without a done frame",
+  };
+}
+
 function frameDataToDispatcherError(data: string): DispatcherError {
   let parsed: unknown;
   try {