@loomcycle/client 0.8.19

package/dist/fetch-helpers.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Shared HTTP plumbing for LoomcycleClient. Three responsibilities:
+ *
+ *   1. Build the Authorization header from the client's bearer token.
+ *   2. JSON encode/decode the request + response.
+ *   3. Map non-2xx responses to typed errors from errors.ts (single
+ *      source of truth — mirrors Python's _raise_from_grpc).
+ *
+ * Method-level code in client.ts stays focused on URL + body shape;
+ * the boring fetch + error-translation machinery lives here.
+ */
+/**
+ * @internal — not part of @loomcycle/client's public API surface.
+ *
+ * Snapshot of the LoomcycleClient constructor inputs threaded through
+ * the helpers below. The leading underscore + this docstring signal
+ * "internal type; consumers MUST NOT depend on it". TypeScript's
+ * declaration emit still publishes it under dist/fetch-helpers.d.ts
+ * (no --stripInternal in tsconfig today), but the rename + comment
+ * make accidental dependence implausible: a consumer doing
+ * `import type { _FetchContext } from "@loomcycle/client"` would have
+ * to deliberately reach for a name marked internal, which is a
+ * "contract violation" gesture rather than a casual import. The
+ * fields here (authToken in plaintext, fetchImpl) are implementation
+ * details that may change without notice. */
+export interface _FetchContext {
+    baseUrl: string;
+    authToken: string | undefined;
+    fetchImpl: typeof fetch;
+}
+/** authHeaders builds the standard request header set: JSON Accept
+ *  + Bearer token when the client was constructed with one. The
+ *  caller adds Content-Type when posting a body. */
+export declare function authHeaders(ctx: _FetchContext): Record<string, string>;
+/** jsonFetch performs a GET and unwraps the JSON body. Non-2xx
+ *  status maps to a typed error via raiseFromResponse. */
+export declare function jsonFetch<T>(ctx: _FetchContext, path: string, opts?: {
+    signal?: AbortSignal;
+}): Promise<T>;
+/** postJSON sends a JSON-encoded body and unwraps the response.
+ *  When `body` is undefined, no body is sent (Content-Type
+ *  omitted). */
+export declare function postJSON<T>(ctx: _FetchContext, path: string, body?: unknown, opts?: {
+    signal?: AbortSignal;
+}): Promise<T>;
+/** deleteRequest sends a DELETE and tolerates 204/200/404-with-
+ *  idempotent-semantics per the loomcycle wire contract. */
+export declare function deleteRequest(ctx: _FetchContext, path: string, opts?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+/**
+ * raiseFromResponse — the single point where HTTP status + body
+ * text get mapped to typed errors. Always throws; the function
+ * signature returns `never` only because TypeScript needs the
+ * return type for control-flow narrowing.
+ *
+ * Mapping table:
+ *
+ *   400         → InvalidArgumentError
+ *   401         → AuthError
+ *   404 + "snapshot"   → SnapshotNotFoundError ────────┐
+ *   404 + "session"    → SessionNotFoundError          │  All extend
+ *   404 + "hook"       → HookNotFoundError             │  NotFoundError —
+ *   404 + "agent"      → AgentNotFoundError            │  callers can
+ *   404 + (other)      → NotFoundError (base)          │  catch any 404
+ *                                                      │  with one
+ *                                                      │  instanceof.
+ *   409 + "already_pausing" / "already paused" → AlreadyPausingError
+ *   409 + "not_paused" / "not paused"          → NotPausedError
+ *   409 + "session"                            → SessionBusyError
+ *   409 + "agent_id"                           → AgentIDInUseError
+ *   409 + (other)                              → LoomcycleError (base)
+ *   413         → SnapshotTooLargeError
+ *   422         → SnapshotVersionError (snapshot-version-too-new/unknown)
+ *   429         → BackpressureError
+ *   503 + "pause manager not configured" → PauseNotConfiguredError
+ *                                          (subclass of UnavailableError)
+ *   503 + (other)                        → UnavailableError
+ *   500-599 (other) → LoomcycleError (base)
+ *   default     → LoomcycleError (base)
+ *
+ * Priority within a status group is most-specific-first; an unknown
+ * 409 falls through to base LoomcycleError so callers see a
+ * meaningful message + status. For 404, the catch-all is NotFoundError
+ * (base) so the v0.8.18-added memory + interrupt routes don't
+ * misclassify into AgentNotFoundError when the 404 body doesn't
+ * mention "agent".
+ */
+export declare function raiseFromResponse(resp: Response): Promise<never>;

package/dist/fetch-helpers.js

@@ -0,0 +1,198 @@
+/**
+ * Shared HTTP plumbing for LoomcycleClient. Three responsibilities:
+ *
+ *   1. Build the Authorization header from the client's bearer token.
+ *   2. JSON encode/decode the request + response.
+ *   3. Map non-2xx responses to typed errors from errors.ts (single
+ *      source of truth — mirrors Python's _raise_from_grpc).
+ *
+ * Method-level code in client.ts stays focused on URL + body shape;
+ * the boring fetch + error-translation machinery lives here.
+ */
+import { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, HookNotFoundError, InvalidArgumentError, LoomcycleError, NotFoundError, NotPausedError, PauseNotConfiguredError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, UnavailableError, } from "./errors.js";
+/** authHeaders builds the standard request header set: JSON Accept
+ *  + Bearer token when the client was constructed with one. The
+ *  caller adds Content-Type when posting a body. */
+export function authHeaders(ctx) {
+    const h = { Accept: "application/json" };
+    if (ctx.authToken)
+        h.Authorization = `Bearer ${ctx.authToken}`;
+    return h;
+}
+/** jsonFetch performs a GET and unwraps the JSON body. Non-2xx
+ *  status maps to a typed error via raiseFromResponse. */
+export async function jsonFetch(ctx, path, opts) {
+    const resp = await ctx.fetchImpl(ctx.baseUrl + path, {
+        method: "GET",
+        headers: authHeaders(ctx),
+        signal: opts?.signal,
+    });
+    if (!resp.ok) {
+        await raiseFromResponse(resp);
+    }
+    return (await resp.json());
+}
+/** postJSON sends a JSON-encoded body and unwraps the response.
+ *  When `body` is undefined, no body is sent (Content-Type
+ *  omitted). */
+export async function postJSON(ctx, path, body, opts) {
+    const headers = authHeaders(ctx);
+    let bodyStr;
+    if (body !== undefined) {
+        headers["Content-Type"] = "application/json";
+        bodyStr = JSON.stringify(body);
+    }
+    const resp = await ctx.fetchImpl(ctx.baseUrl + path, {
+        method: "POST",
+        headers,
+        body: bodyStr,
+        signal: opts?.signal,
+    });
+    if (!resp.ok) {
+        await raiseFromResponse(resp);
+    }
+    // Some endpoints return 204 No Content; tolerate that with a
+    // null cast — typed methods that know they return 204 use a
+    // void wrapper instead.
+    if (resp.status === 204)
+        return null;
+    return (await resp.json());
+}
+/** deleteRequest sends a DELETE and tolerates 204/200/404-with-
+ *  idempotent-semantics per the loomcycle wire contract. */
+export async function deleteRequest(ctx, path, opts) {
+    const resp = await ctx.fetchImpl(ctx.baseUrl + path, {
+        method: "DELETE",
+        headers: authHeaders(ctx),
+        signal: opts?.signal,
+    });
+    if (!resp.ok) {
+        await raiseFromResponse(resp);
+    }
+}
+/**
+ * raiseFromResponse — the single point where HTTP status + body
+ * text get mapped to typed errors. Always throws; the function
+ * signature returns `never` only because TypeScript needs the
+ * return type for control-flow narrowing.
+ *
+ * Mapping table:
+ *
+ *   400         → InvalidArgumentError
+ *   401         → AuthError
+ *   404 + "snapshot"   → SnapshotNotFoundError ────────┐
+ *   404 + "session"    → SessionNotFoundError          │  All extend
+ *   404 + "hook"       → HookNotFoundError             │  NotFoundError —
+ *   404 + "agent"      → AgentNotFoundError            │  callers can
+ *   404 + (other)      → NotFoundError (base)          │  catch any 404
+ *                                                      │  with one
+ *                                                      │  instanceof.
+ *   409 + "already_pausing" / "already paused" → AlreadyPausingError
+ *   409 + "not_paused" / "not paused"          → NotPausedError
+ *   409 + "session"                            → SessionBusyError
+ *   409 + "agent_id"                           → AgentIDInUseError
+ *   409 + (other)                              → LoomcycleError (base)
+ *   413         → SnapshotTooLargeError
+ *   422         → SnapshotVersionError (snapshot-version-too-new/unknown)
+ *   429         → BackpressureError
+ *   503 + "pause manager not configured" → PauseNotConfiguredError
+ *                                          (subclass of UnavailableError)
+ *   503 + (other)                        → UnavailableError
+ *   500-599 (other) → LoomcycleError (base)
+ *   default     → LoomcycleError (base)
+ *
+ * Priority within a status group is most-specific-first; an unknown
+ * 409 falls through to base LoomcycleError so callers see a
+ * meaningful message + status. For 404, the catch-all is NotFoundError
+ * (base) so the v0.8.18-added memory + interrupt routes don't
+ * misclassify into AgentNotFoundError when the 404 body doesn't
+ * mention "agent".
+ */
+export async function raiseFromResponse(resp) {
+    const status = resp.status;
+    // Read body with a cap; many error bodies are JSON {error, message}
+    // shape but raw text is fine for matching keywords.
+    let bodyText = "";
+    try {
+        bodyText = await resp.text();
+    }
+    catch {
+        // network-level body read failure — fall through with empty body
+    }
+    const bodyLower = bodyText.toLowerCase();
+    // HTTP/2 strips reason phrases — Node's undici fetch returns "" for
+    // resp.statusText on HTTP/2 responses. Fall back to a stock phrase
+    // for the common status codes so the error message reads cleanly
+    // ("401 Unauthorized" not "401 " with a trailing space).
+    const statusPhrase = resp.statusText || stockStatusPhrase(status);
+    const msg = bodyText.trim() ? bodyText.slice(0, 1024) : `${status} ${statusPhrase}`;
+    const opts = { status, bodyText: bodyText.slice(0, 1024) };
+    switch (status) {
+        case 400:
+            throw new InvalidArgumentError(msg, opts);
+        case 401:
+            throw new AuthError(msg, opts);
+        case 404:
+            // Priority: most-specific keyword wins.
+            // - "snapshot" → SnapshotNotFoundError
+            // - "session"  → SessionNotFoundError
+            // - "hook"     → HookNotFoundError (must precede "agent" — the
+            //                hooks 404 body is `no hook with id "..."`,
+            //                doesn't mention "agent")
+            // - "agent" or "agent_id" → AgentNotFoundError
+            // - otherwise → NotFoundError (base) — e.g. memory rows, interrupts,
+            //   or any future 404-returning endpoint that doesn't fit the
+            //   existing keyword set.
+            if (bodyLower.includes("snapshot"))
+                throw new SnapshotNotFoundError(msg, opts);
+            if (bodyLower.includes("session"))
+                throw new SessionNotFoundError(msg, opts);
+            if (bodyLower.includes("hook"))
+                throw new HookNotFoundError(msg, opts);
+            if (bodyLower.includes("agent"))
+                throw new AgentNotFoundError(msg, opts);
+            throw new NotFoundError(msg, opts);
+        case 409:
+            if (bodyLower.includes("already_pausing") || bodyLower.includes("already paused"))
+                throw new AlreadyPausingError(msg, opts);
+            if (bodyLower.includes("not_paused") || bodyLower.includes("not paused"))
+                throw new NotPausedError(msg, opts);
+            if (bodyLower.includes("session"))
+                throw new SessionBusyError(msg, opts);
+            if (bodyLower.includes("agent_id"))
+                throw new AgentIDInUseError(msg, opts);
+            throw new LoomcycleError(msg, opts);
+        case 413:
+            throw new SnapshotTooLargeError(msg, opts);
+        case 422:
+            throw new SnapshotVersionError(msg, opts);
+        case 429:
+            throw new BackpressureError(msg, opts);
+        case 503:
+            if (bodyLower.includes("pause") && bodyLower.includes("not configured"))
+                throw new PauseNotConfiguredError(msg, opts);
+            throw new UnavailableError(msg, opts);
+        default:
+            throw new LoomcycleError(msg, opts);
+    }
+}
+/** stockStatusPhrase returns a stock reason phrase for the common
+ *  HTTP statuses raiseFromResponse handles. Used as a fallback when
+ *  Response.statusText is empty (HTTP/2 strips reason phrases). */
+function stockStatusPhrase(status) {
+    switch (status) {
+        case 400: return "Bad Request";
+        case 401: return "Unauthorized";
+        case 403: return "Forbidden";
+        case 404: return "Not Found";
+        case 409: return "Conflict";
+        case 413: return "Payload Too Large";
+        case 422: return "Unprocessable Entity";
+        case 429: return "Too Many Requests";
+        case 500: return "Internal Server Error";
+        case 502: return "Bad Gateway";
+        case 503: return "Service Unavailable";
+        case 504: return "Gateway Timeout";
+        default: return "HTTP " + status;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @loomcycle/client — TypeScript client for the loomcycle sidecar.
+ *
+ * Public surface (v0.8.18 — Python-adapter parity):
+ *
+ *   class LoomcycleClient
+ *     constructor(opts: ClientOptions)
+ *
+ *     // Run lifecycle (SSE streams)
+ *     runStreaming(opts: RunOptions): AsyncIterable<AgentEvent>
+ *     continueSession(opts: ContinueOptions): AsyncIterable<AgentEvent>
+ *
+ *     // Agent metadata
+ *     getAgent(agentId): Promise<Agent>
+ *     cancelAgent(agentId, opts?): Promise<CancelAgentResult>
+ *     listUserAgents(userId, opts?): Promise<Agent[]>
+ *     getTranscript(sessionId): Promise<TranscriptResponse>
+ *     health(): Promise<HealthResponse>
+ *     listUsers(): Promise<ListUsersResponse>
+ *
+ *     // Pause / Resume / State (v0.8.17/8.18)
+ *     pauseRuntime(opts?): Promise<PauseResult>
+ *     resumeRuntime(): Promise<ResumeResult>
+ *     getRuntimeState(): Promise<RuntimeStateResponse>
+ *
+ *     // Snapshot lifecycle (v0.8.17/8.18)
+ *     createSnapshot(opts?): Promise<SnapshotCreateResponse>
+ *     listSnapshots(opts?): Promise<SnapshotDescriptor[]>
+ *     getSnapshot(id): Promise<SnapshotEnvelope>
+ *     exportSnapshotURL(id): string  (synchronous; returns a URL)
+ *     restoreSnapshot(opts): Promise<SnapshotRestoreResponse>
+ *     deleteSnapshot(id): Promise<void>
+ *
+ *     // Memory admin
+ *     listMemoryScopes(): Promise<MemoryScopesResponse>
+ *     listMemoryScopeIDs(scope): Promise<MemoryScopeIDsResponse>
+ *     listMemoryEntries(scope, scopeID, opts?): Promise<MemoryEntriesResponse>
+ *     getMemoryEntry(scope, scopeID, key): Promise<MemoryEntryResponse>
+ *
+ *     // Interruption (v0.8.16)
+ *     listUserInterrupts(userId, opts?): Promise<InterruptListResponse>
+ *     listRunInterrupts(runId, opts?): Promise<InterruptListResponse>
+ *     resolveInterrupt(runId, interruptId, opts): Promise<unknown>
+ *
+ *   Errors (typed subclasses of LoomcycleError; see README for the
+ *   full HTTP-status → typed-error mapping table):
+ *     LoomcycleError, AgentNotFoundError, SessionNotFoundError,
+ *     SessionBusyError, AgentIDInUseError, BackpressureError,
+ *     AuthError, UnavailableError, InvalidArgumentError,
+ *     PauseNotConfiguredError (subclass of UnavailableError),
+ *     AlreadyPausingError, NotPausedError, SnapshotNotFoundError,
+ *     SnapshotTooLargeError, SnapshotVersionError
+ *
+ * Transport: HTTP+SSE. Auth: Bearer token via the Authorization
+ * header. Designed for Node ≥18 (engines pinned); Bun/Deno likely
+ * work but untested. Browser support is not a target (use the
+ * Web UI for browser-side operator control).
+ *
+ * See `adapters/ts/README.md` for usage examples.
+ */
+export { LoomcycleClient } from "./client.js";
+export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, PromptContent, PromptSegment, RetryInfo, RunOptions, ToolUse, Usage, Agent, AgentStatus, AgentUsage, CancelAgentResult, ListAgentsResponse, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, PauseResult, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, Hook, HookFailMode, HookPhase, HookToolCall, HookToolResult, ListHooksResponse, PostHookCall, PostHookResult, PreHookCall, PreHookResult, RegisterHookOptions, RegisterHookResponse, } from "./types.js";
+export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, HookNotFoundError, NotFoundError, InvalidArgumentError, LoomcycleError, NotPausedError, PauseNotConfiguredError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, UnavailableError, } from "./errors.js";

package/dist/index.js

@@ -0,0 +1,62 @@
+/**
+ * @loomcycle/client — TypeScript client for the loomcycle sidecar.
+ *
+ * Public surface (v0.8.18 — Python-adapter parity):
+ *
+ *   class LoomcycleClient
+ *     constructor(opts: ClientOptions)
+ *
+ *     // Run lifecycle (SSE streams)
+ *     runStreaming(opts: RunOptions): AsyncIterable<AgentEvent>
+ *     continueSession(opts: ContinueOptions): AsyncIterable<AgentEvent>
+ *
+ *     // Agent metadata
+ *     getAgent(agentId): Promise<Agent>
+ *     cancelAgent(agentId, opts?): Promise<CancelAgentResult>
+ *     listUserAgents(userId, opts?): Promise<Agent[]>
+ *     getTranscript(sessionId): Promise<TranscriptResponse>
+ *     health(): Promise<HealthResponse>
+ *     listUsers(): Promise<ListUsersResponse>
+ *
+ *     // Pause / Resume / State (v0.8.17/8.18)
+ *     pauseRuntime(opts?): Promise<PauseResult>
+ *     resumeRuntime(): Promise<ResumeResult>
+ *     getRuntimeState(): Promise<RuntimeStateResponse>
+ *
+ *     // Snapshot lifecycle (v0.8.17/8.18)
+ *     createSnapshot(opts?): Promise<SnapshotCreateResponse>
+ *     listSnapshots(opts?): Promise<SnapshotDescriptor[]>
+ *     getSnapshot(id): Promise<SnapshotEnvelope>
+ *     exportSnapshotURL(id): string  (synchronous; returns a URL)
+ *     restoreSnapshot(opts): Promise<SnapshotRestoreResponse>
+ *     deleteSnapshot(id): Promise<void>
+ *
+ *     // Memory admin
+ *     listMemoryScopes(): Promise<MemoryScopesResponse>
+ *     listMemoryScopeIDs(scope): Promise<MemoryScopeIDsResponse>
+ *     listMemoryEntries(scope, scopeID, opts?): Promise<MemoryEntriesResponse>
+ *     getMemoryEntry(scope, scopeID, key): Promise<MemoryEntryResponse>
+ *
+ *     // Interruption (v0.8.16)
+ *     listUserInterrupts(userId, opts?): Promise<InterruptListResponse>
+ *     listRunInterrupts(runId, opts?): Promise<InterruptListResponse>
+ *     resolveInterrupt(runId, interruptId, opts): Promise<unknown>
+ *
+ *   Errors (typed subclasses of LoomcycleError; see README for the
+ *   full HTTP-status → typed-error mapping table):
+ *     LoomcycleError, AgentNotFoundError, SessionNotFoundError,
+ *     SessionBusyError, AgentIDInUseError, BackpressureError,
+ *     AuthError, UnavailableError, InvalidArgumentError,
+ *     PauseNotConfiguredError (subclass of UnavailableError),
+ *     AlreadyPausingError, NotPausedError, SnapshotNotFoundError,
+ *     SnapshotTooLargeError, SnapshotVersionError
+ *
+ * Transport: HTTP+SSE. Auth: Bearer token via the Authorization
+ * header. Designed for Node ≥18 (engines pinned); Bun/Deno likely
+ * work but untested. Browser support is not a target (use the
+ * Web UI for browser-side operator control).
+ *
+ * See `adapters/ts/README.md` for usage examples.
+ */
+export { LoomcycleClient } from "./client.js";
+export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, HookNotFoundError, NotFoundError, InvalidArgumentError, LoomcycleError, NotPausedError, PauseNotConfiguredError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, UnavailableError, } from "./errors.js";

package/dist/stream.d.ts

@@ -0,0 +1,17 @@
+import type { AgentEvent } from "./types.js";
+/**
+ * parseSSE turns a chunked byte stream into typed AgentEvents.
+ *
+ * SSE framing (subset): "event: <name>\ndata: <json>\n\n". We only emit a
+ * frame when both event + data have been seen since the last blank line.
+ *
+ * Used by `runStreaming` and `continueSession` — both POST endpoints
+ * return the same SSE wire shape and the parser doesn't differentiate.
+ *
+ * Side-channel frames: the v0.4 `event: agent` SSE frame (and any future
+ * sse.sendRaw user) emits a JSON payload that does NOT carry the `type`
+ * field — the SSE event name is the only discriminator. parseSSE backfills
+ * `type` from the event name in that case so consumers see a well-formed
+ * AgentEvent and switch on `ev.type` uniformly.
+ */
+export declare function parseSSE(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncIterable<AgentEvent>;

package/dist/stream.js

@@ -0,0 +1,81 @@
+/**
+ * parseSSE turns a chunked byte stream into typed AgentEvents.
+ *
+ * SSE framing (subset): "event: <name>\ndata: <json>\n\n". We only emit a
+ * frame when both event + data have been seen since the last blank line.
+ *
+ * Used by `runStreaming` and `continueSession` — both POST endpoints
+ * return the same SSE wire shape and the parser doesn't differentiate.
+ *
+ * Side-channel frames: the v0.4 `event: agent` SSE frame (and any future
+ * sse.sendRaw user) emits a JSON payload that does NOT carry the `type`
+ * field — the SSE event name is the only discriminator. parseSSE backfills
+ * `type` from the event name in that case so consumers see a well-formed
+ * AgentEvent and switch on `ev.type` uniformly.
+ */
+export async function* parseSSE(reader) {
+    const decoder = new TextDecoder("utf-8");
+    let buf = "";
+    let event = "";
+    let data = "";
+    const flush = () => {
+        if (!event && !data)
+            return null;
+        if (!data) {
+            event = "";
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(data);
+            // Side-channel sendRaw frames omit `type` in the JSON payload — the
+            // SSE event name is the only discriminator. Backfill it so the
+            // consumer's switch on ev.type doesn't miss these.
+            if (!parsed.type && event) {
+                parsed.type = event;
+            }
+            event = "";
+            data = "";
+            return parsed;
+        }
+        catch {
+            event = "";
+            data = "";
+            return null;
+        }
+    };
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buf += decoder.decode(value, { stream: true });
+        let idx;
+        while ((idx = buf.indexOf("\n")) !== -1) {
+            const line = buf.slice(0, idx).replace(/\r$/, "");
+            buf = buf.slice(idx + 1);
+            if (line === "") {
+                const ev = flush();
+                if (ev)
+                    yield ev;
+                continue;
+            }
+            if (line.startsWith("event:"))
+                event = line.slice("event:".length).trim();
+            else if (line.startsWith("data:"))
+                data = line.slice("data:".length).trim();
+        }
+    }
+    // Stream ended. Drain any unterminated final line still in `buf` — a
+    // connection drop can land here mid-frame, and without this step the
+    // last frame whose `\n` never arrived would be silently lost. Then
+    // flush any pending event + data.
+    if (buf.length > 0) {
+        const line = buf.replace(/\r$/, "");
+        if (line.startsWith("event:"))
+            event = line.slice("event:".length).trim();
+        else if (line.startsWith("data:"))
+            data = line.slice("data:".length).trim();
+    }
+    const ev = flush();
+    if (ev)
+        yield ev;
+}