@tetsujs/sse 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tetsuodev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# @tetsujs/sse
+
+Server-sent events from an async generator, and the same machinery for any
+other streamed format.
+
+```bash
+bun add @tetsujs/sse
+```
+
+## Usage
+
+```ts
+import { sse } from "@tetsujs/sse";
+
+route({
+  method: "GET",
+  path: "/prices",
+  handler: (ctx) =>
+    sse(ctx, async function* (signal) {
+      for await (const price of prices.watch({ signal })) {
+        yield { data: price, id: price.at };
+      }
+    }),
+});
+```
+
+`sse()` sets the SSE headers, frames every event, sends a keep-alive
+comment every 15 seconds so proxies do not close an idle connection, and
+pulls events one at a time — a client that stops reading stops the
+generator instead of filling memory.
+
+An event:
+
+```ts
+yield {
+  data: { price: 42 }, // a string is sent as is, anything else as JSON
+  event: "tick",       // the name for addEventListener
+  id: "1712",          // sent back as Last-Event-ID when the browser reconnects
+  retry: 3_000,        // how long the browser waits before reconnecting
+};
+```
+
+## Resuming
+
+A browser that lost the connection reconnects with the last id it saw.
+`lastEventId(ctx)` reads it, so the stream can continue from there:
+
+```ts
+import { lastEventId, sse } from "@tetsujs/sse";
+
+handler: (ctx) =>
+  sse(ctx, async function* () {
+    for await (const item of history.since(lastEventId(ctx))) {
+      yield { data: item, id: item.id };
+    }
+  }),
+```
+
+## Cleaning up
+
+The generator receives an `AbortSignal` that fires when the stream is over
+— the client left, the response was discarded, or the generator finished.
+
+A generator that yields regularly needs nothing more: when the client
+leaves, its loop ends and its `finally` runs. **A generator that can go
+quiet must pass the signal on** to whatever it waits for — a queue with no
+traffic, a poll of something unchanged. Otherwise it waits forever and is
+never cleaned up:
+
+```ts
+sse(ctx, async function* (signal) {
+  const queue = await broker.subscribe("prices", { signal });
+
+  try {
+    for await (const price of queue) {
+      yield { data: price, id: price.at };
+    }
+  } finally {
+    await queue.close();
+  }
+});
+```
+
+A generator that throws ends the stream where it stood, and the error is
+logged as `[tetsu] stream generator failed:` — the response has already
+left, so there is no `onError` to hand it to.
+
+## Knowing what a stream did
+
+An access log sees a stream when it starts, so it records a long feed as a
+fast `200`. `onEnd` reports how it actually ended:
+
+```ts
+sse(ctx, feed, {
+  onEnd: (summary) => logger.info({ ...summary, requestId: ctx.requestId }, "stream closed"),
+});
+// { events: 412, bytes: 38104, durationMs: 2401882.6, reason: "cancelled" }
+```
+
+`reason` is `"ended"` (the generator finished), `"cancelled"` (the client
+left, or the response was discarded) or `"failed"` (the generator threw).
+
+## Other formats: `stream()`
+
+`sse()` is `stream()` with SSE framing on top. For anything else — NDJSON,
+CSV, a model's tokens — `stream()` takes the chunks as they are, with the
+same backpressure, signal and summary:
+
+```ts
+import { stream } from "@tetsujs/sse";
+
+handler: (ctx) =>
+  stream(
+    ctx,
+    async function* (signal) {
+      for await (const row of rows.watch({ signal })) {
+        yield `${JSON.stringify(row)}\n`;
+      }
+    },
+    { contentType: "application/x-ndjson" },
+  ),
+```
+
+`stream()` sends no keep-alives unless asked, because not every format has
+a line a client will ignore:
+
+```ts
+{ keepAlive: { everyMs: 15_000, chunk: "\n" } }
+```
+
+## Options
+
+| `sse()` | Default | |
+| --- | --- | --- |
+| `heartbeatMs` | `15000` | keep-alive interval; `0` turns it off |
+| `status` | `200` | |
+| `onEnd` | — | receives the summary when the stream ends |
+
+| `stream()` | Default | |
+| --- | --- | --- |
+| `contentType` | none | the `content-type` header |
+| `status` | `200` | |
+| `headers` | — | more response headers |
+| `keepAlive` | off | `{ everyMs, chunk }` |
+| `onEnd` | — | receives the summary; it counts `chunks` instead of `events` |

package/dist/src/index.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Server-sent events.
+ *
+ * ```ts
+ * route({
+ *   method: "GET",
+ *   path: "/prices",
+ *   handler: (ctx) =>
+ *     sse(ctx, async function* (signal) {
+ *       for await (const price of prices.watch({ signal })) {
+ *         yield { data: price, id: price.at };
+ *       }
+ *     }),
+ * });
+ * ```
+ *
+ * The framework needs none of this to stream — a handler returning a
+ * `Response` with a stream already works. What this adds is the part that
+ * is easy to get quietly wrong: the wire format (a blank line ends an
+ * event, and every line of a multi-line payload carries its own `data:`
+ * prefix), the headers a proxy needs to see, the heartbeat that keeps an
+ * idle connection from being closed by one, an `AbortSignal` that says the
+ * stream is over so a source that waits can stop waiting, and the
+ * backpressure that makes a slow client cost a buffer rather than a heap:
+ * events are produced on demand, one at a time, at the rate they are
+ * read.
+ *
+ * @module
+ */
+import type { BaseCtx } from "@tetsujs/core";
+import type { StreamReason, StreamSummary } from "./stream.ts";
+export type { KeepAlive, StreamOptions, StreamReason, StreamSummary, } from "./stream.ts";
+export { stream } from "./stream.ts";
+/**
+ * One event, as it goes over the wire.
+ *
+ * `data` is deliberately untyped. A stream usually carries several kinds
+ * of event under different names, so one type parameter would be wrong for
+ * all but the simplest feed — and nothing on the server consumes the
+ * payload's type anyway: it leaves as JSON. A feed that is uniform can say
+ * so where it is written, by typing its own generator.
+ */
+export interface ServerSentEvent {
+    /**
+     * The payload. A string is sent as it is; anything else is JSON, which
+     * is what a browser's `EventSource` expects to parse. A value JSON has
+     * no form for — `undefined`, a function, a symbol — is refused rather
+     * than sent as an empty string: a payload that went missing, a
+     * `map.get()` that found nothing, would reach the page as a valid event
+     * with nothing in it.
+     */
+    readonly data: unknown;
+    /** Event name, read by `addEventListener(name)` rather than `onmessage`. */
+    readonly event?: string;
+    /**
+     * Event id. The browser sends the last one back as `Last-Event-ID` when
+     * it reconnects, which is how a stream resumes where it stopped.
+     */
+    readonly id?: string | number;
+    /** How long the browser waits before reconnecting, in milliseconds. */
+    readonly retry?: number;
+}
+/** How the stream behaves. */
+export interface SseOptions {
+    /**
+     * How often a comment line is sent to keep the connection alive, in
+     * milliseconds. Defaults to 15 seconds; `0` turns it off.
+     *
+     * On by default because the failure it prevents is silent and remote: a
+     * proxy between the server and the browser closes a connection that has
+     * been idle — nginx after 60 seconds by default — and the application
+     * sees a client that keeps reconnecting for no visible reason.
+     */
+    readonly heartbeatMs?: number;
+    /** Status of the response. `200` by default. */
+    readonly status?: number;
+    /**
+     * Called once when the stream is over, with what it did.
+     *
+     * The gap this closes: `afterResponse` runs when the response is handed
+     * to the runtime, which for a stream is the moment it *starts*. An
+     * access log therefore records a forty-minute feed as a `200` that took
+     * microseconds, and a torn connection as a success. Delivery to the
+     * client is not observable in the fetch model and stays that way — but
+     * the end of *generation* is, and that is what this reports.
+     *
+     * It carries no request id on purpose. This callback is written at the
+     * call site, where `ctx` is already in scope, so the caller adds
+     * whatever identifies the request better than this package could guess.
+     *
+     * @example
+     * ```ts
+     * sse(ctx, feed, {
+     *   onEnd: (summary) =>
+     *     logger.info({ ...summary, requestId: ctx.requestId }, "stream closed"),
+     * });
+     * ```
+     */
+    readonly onEnd?: (summary: SseSummary) => void;
+}
+/**
+ * How an SSE stream ended — {@link StreamReason} by another name, because
+ * a reader of this package should not have to go looking.
+ */
+export type SseReason = StreamReason;
+/**
+ * One finished stream, as server-sent events count it.
+ *
+ * The same record {@link StreamSummary} carries, with `chunks` named
+ * `events`: for this helper one chunk is one event, and the word an author
+ * reads at the call site should be the one they wrote.
+ */
+export interface SseSummary extends Omit<StreamSummary, "chunks"> {
+    /** Events yielded and written, not counting heartbeats. */
+    readonly events: number;
+}
+/**
+ * Builds a server-sent events response from an async generator.
+ *
+ * The generator is handed an `AbortSignal` that fires when the stream is
+ * over, whichever way it ended — the client disconnected, the consumer
+ * cancelled, the generator itself failed. It is not `ctx.req.signal`
+ * directly: a source wants to know that this stream is finished, not which
+ * of the ways finished it.
+ *
+ * **Passing it on is what makes cleanup work**, and it is the caller's job
+ * rather than this package's. A generator between two `yield`s leaves on
+ * its own — the loop sees the abort at the next value, ends the `for
+ * await`, and the language calls the generator's `return()`, which runs
+ * its `finally`. A generator parked inside an `await` is resumed by
+ * nothing: `return()` on it is queued behind that `await` and applies only
+ * once it settles, so an `await` on a source that has gone quiet never
+ * unwinds, and the subscription inside it lives as long as the process.
+ * Neither `cancel()` on the stream nor `return()` on the generator changes
+ * that — both were measured, both fire, neither wakes it — which is why
+ * the signal goes to the source instead.
+ *
+ * So the rule, stated plainly: **a stream ends with the connection if its
+ * generator keeps yielding, or if it waits on the signal.** A generator
+ * that does neither leaks, and no amount of care out here can collect it.
+ *
+ * A generator that fails instead of ending is logged and the stream is
+ * closed where it stood, so what already went out stays valid and the
+ * client sees an ordinary end of stream. Letting the failure escape
+ * `start()` instead would reach no one the application can hear: the
+ * platform prints a raw stack and tears the connection down, and whether
+ * the bytes already queued are lost with it depends on whether a macrotask
+ * happened to run in between.
+ *
+ * @example A source that yields on its own — the loop ends it.
+ * ```ts
+ * sse(ctx, async function* () {
+ *   const subscription = topic.subscribe();
+ *
+ *   try {
+ *     for await (const message of subscription) {
+ *       yield { event: "message", data: message, id: message.id };
+ *     }
+ *   } finally {
+ *     subscription.close();
+ *   }
+ * });
+ * ```
+ *
+ * @example A source that can go quiet — it has to take the signal.
+ * ```ts
+ * sse(ctx, async function* (signal) {
+ *   const queue = await broker.subscribe("prices", { signal });
+ *
+ *   try {
+ *     for await (const price of queue) {
+ *       yield { data: price, id: price.at };
+ *     }
+ *   } finally {
+ *     await queue.close();
+ *   }
+ * });
+ * ```
+ */
+export declare function sse(ctx: BaseCtx, source: (signal: AbortSignal) => AsyncGenerator<ServerSentEvent, void, undefined>, options?: SseOptions): Response;
+/**
+ * Formats one event.
+ *
+ * Every line of the payload carries its own `data:` prefix — a raw line
+ * break inside one would otherwise end the field — and a blank line ends
+ * the event, which is what makes the client dispatch it.
+ */
+export declare function frame(event: ServerSentEvent): string;
+/**
+ * The id the client last received, when it is reconnecting.
+ *
+ * A browser sends it automatically after a dropped connection; a stream
+ * that yields ids can resume from it instead of starting over.
+ *
+ * @example
+ * ```ts
+ * handler: (ctx) =>
+ *   sse(ctx, async function* () {
+ *     for await (const item of history.since(lastEventId(ctx))) {
+ *       yield { data: item, id: item.id };
+ *     }
+ *   });
+ * ```
+ */
+export declare function lastEventId(ctx: BaseCtx): string | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG/D,YAAY,EACV,SAAS,EACT,aAAa,EACb,YAAY,EACZ,aAAa,GACd,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAEvB,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE9B,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,8BAA8B;AAC9B,MAAM,WAAW,UAAU;IACzB;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B,gDAAgD;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,CAAC;CAChD;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,WAAW,UAAW,SAAQ,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC;IAC/D,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,GAAG,CACjB,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,CACN,MAAM,EAAE,WAAW,KAChB,cAAc,CAAC,eAAe,EAAE,IAAI,EAAE,SAAS,CAAC,EACrD,OAAO,GAAE,UAAe,GACvB,QAAQ,CAsCV;AAcD;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CA6BpD;AA6BD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE5D"}

package/dist/src/index.js

@@ -0,0 +1,153 @@
+// @bun
+// packages/sse/src/stream.ts
+function stream(ctx, source, options = {}) {
+  const encoder = new TextEncoder;
+  const ending = new AbortController;
+  const signal = AbortSignal.any([ctx.req.signal, ending.signal]);
+  const chunks = source(signal);
+  const startedAt = performance.now();
+  let beating;
+  let written = 0;
+  let bytes = 0;
+  let over = false;
+  const done = (reason) => {
+    if (beating !== undefined) {
+      clearInterval(beating);
+      beating = undefined;
+    }
+    ending.abort();
+    if (over) {
+      return;
+    }
+    over = true;
+    try {
+      options.onEnd?.({
+        chunks: written,
+        bytes,
+        durationMs: Math.round((performance.now() - startedAt) * 1000) / 1000,
+        reason
+      });
+    } catch (error) {
+      console.error("[tetsu] stream onEnd failed:", error);
+    }
+  };
+  const emit = (controller, chunk) => {
+    const encoded = encoder.encode(chunk);
+    bytes += encoded.byteLength;
+    controller.enqueue(encoded);
+  };
+  const body = new ReadableStream({
+    start(controller) {
+      const alive = options.keepAlive;
+      if (!alive || alive.everyMs <= 0) {
+        return;
+      }
+      beating = setInterval(() => {
+        if ((controller.desiredSize ?? 0) <= 0) {
+          return;
+        }
+        try {
+          emit(controller, alive.chunk);
+        } catch {
+          done("cancelled");
+        }
+      }, alive.everyMs);
+    },
+    async pull(controller) {
+      try {
+        const next = await chunks.next();
+        if (next.done || signal.aborted) {
+          done(signal.aborted ? "cancelled" : "ended");
+          close(controller);
+          return;
+        }
+        written += 1;
+        emit(controller, next.value);
+      } catch (error) {
+        console.error("[tetsu] stream generator failed:", error);
+        done("failed");
+        close(controller);
+      }
+    },
+    cancel() {
+      done("cancelled");
+      chunks.return();
+    }
+  });
+  return new Response(body, {
+    status: options.status ?? 200,
+    headers: {
+      ...options.contentType ? { "content-type": options.contentType } : undefined,
+      ...options.headers
+    }
+  });
+}
+function close(controller) {
+  try {
+    controller.close();
+  } catch {}
+}
+
+// packages/sse/src/index.ts
+function sse(ctx, source, options = {}) {
+  const heartbeatMs = options.heartbeatMs ?? 15000;
+  const { onEnd } = options;
+  return stream(ctx, async function* (signal) {
+    for await (const event of source(signal)) {
+      yield frame(event);
+    }
+  }, {
+    contentType: "text/event-stream",
+    headers: { "cache-control": "no-cache" },
+    ...options.status === undefined ? {} : { status: options.status },
+    ...heartbeatMs > 0 ? { keepAlive: { everyMs: heartbeatMs, chunk: `: ping
+
+` } } : {},
+    ...onEnd ? {
+      onEnd: ({ chunks, ...rest }) => onEnd({ ...rest, events: chunks })
+    } : {}
+  });
+}
+var lineBreak = /\r\n|[\r\n]/;
+var unrepresentable = /[\r\n\0]/;
+function frame(event) {
+  const lines = [];
+  if (event.event !== undefined) {
+    lines.push(`event: ${single("event", event.event)}`);
+  }
+  if (event.id !== undefined) {
+    lines.push(`id: ${single("id", String(event.id))}`);
+  }
+  if (event.retry !== undefined) {
+    lines.push(`retry: ${event.retry}`);
+  }
+  const payload = typeof event.data === "string" ? event.data : JSON.stringify(event.data);
+  if (payload === undefined) {
+    throw new TypeError(`an SSE event's data has no JSON form: ${typeof event.data}`);
+  }
+  for (const line of payload.split(lineBreak)) {
+    lines.push(`data: ${line}`);
+  }
+  return `${lines.join(`
+`)}
+
+`;
+}
+function single(field, value) {
+  if (unrepresentable.test(value)) {
+    throw new TypeError(`an SSE ${field} cannot contain a line break or NUL: ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function lastEventId(ctx) {
+  return ctx.req.headers.get("last-event-id") ?? undefined;
+}
+export {
+  frame,
+  lastEventId,
+  sse,
+  stream
+};
+
+//# debugId=41A90C435B2C5A2764756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/stream.ts", "../src/index.ts"],
+  "sourcesContent": [
+    "/**\n * A generator, piped to a response at the rate the client reads it.\n *\n * This is the machinery `sse()` is built on, exported because the wire\n * format is the only part of it that is about server-sent events. A\n * server-to-server feed wants newline-delimited JSON, an export wants CSV,\n * a proxy wants whatever it was handed — and none of them should have to\n * rediscover backpressure, the abort signal, ending the generator on\n * cancellation, or reporting what the stream did.\n *\n * ```ts\n * handler: (ctx) =>\n *   stream(\n *     ctx,\n *     async function* (signal) {\n *       for await (const row of rows.watch({ signal })) {\n *         yield `${JSON.stringify(row)}\\n`;\n *       }\n *     },\n *     { contentType: \"application/x-ndjson\" },\n *   );\n * ```\n *\n * @module\n */\n\nimport type { BaseCtx } from \"@tetsujs/core\";\n\n/** How a stream ended. */\nexport type StreamReason =\n  /** The generator ran out on its own. */\n  | \"ended\"\n  /**\n   * Nobody is reading any more — the client disconnected, or the pipeline\n   * discarded the response the stream was the body of.\n   */\n  | \"cancelled\"\n  /** The generator threw. What had already gone out stayed valid. */\n  | \"failed\";\n\n/** One finished stream. */\nexport interface StreamSummary {\n  /**\n   * Chunks the generator yielded and the stream wrote, not counting\n   * keep-alives. For `sse()` that is one per event.\n   */\n  readonly chunks: number;\n\n  /**\n   * Bytes enqueued, keep-alives included — what the stream put on the wire\n   * rather than what the application meant to say.\n   */\n  readonly bytes: number;\n\n  /** How long the stream lived, in milliseconds, to the microsecond. */\n  readonly durationMs: number;\n\n  readonly reason: StreamReason;\n}\n\n/** Something written on a schedule, so an idle connection stays open. */\nexport interface KeepAlive {\n  /** How often, in milliseconds. */\n  readonly everyMs: number;\n\n  /**\n   * What to write. It has to be something the consumer's parser ignores —\n   * a comment in a format that has them, a blank line in one that does\n   * not, nothing at all in a format where neither is true.\n   */\n  readonly chunk: string;\n}\n\n/** How the stream behaves and what it answers with. */\nexport interface StreamOptions {\n  /** The response's `content-type`. Omitted, none is set. */\n  readonly contentType?: string;\n\n  /** Status of the response. `200` by default. */\n  readonly status?: number;\n\n  /** Headers to send alongside — `cache-control`, and whatever else. */\n  readonly headers?: Record<string, string>;\n\n  /** A filler written while nothing else is. Off by default. */\n  readonly keepAlive?: KeepAlive;\n\n  /** Called once when the stream is over, with what it did. */\n  readonly onEnd?: (summary: StreamSummary) => void;\n}\n\n/**\n * Builds a streaming response from an async generator.\n *\n * The generator is handed an `AbortSignal` that fires when the stream is\n * over, whichever way it ended — the client disconnected, the consumer\n * cancelled, the generator itself failed. It is not `ctx.req.signal`\n * directly: a source wants to know that this stream is finished, not which\n * of the ways finished it.\n *\n * **Passing it on is what makes cleanup work**, and it is the caller's job\n * rather than this module's. A generator between two `yield`s leaves on\n * its own — the loop sees the abort at the next chunk, and `return()` runs\n * its `finally`. A generator parked inside an `await` is resumed by\n * nothing: `return()` on it is queued behind that `await` and applies only\n * once it settles, so an `await` on a source that has gone quiet never\n * unwinds, and the subscription inside it lives as long as the process.\n * Neither cancelling the stream nor `return()` changes that — both were\n * measured, both fire, neither wakes it — which is why the signal goes to\n * the source instead.\n *\n * So the rule, stated plainly: **a stream ends with the connection if its\n * generator keeps yielding, or if it waits on the signal.** A generator\n * that does neither leaks, and no amount of care out here can collect it.\n *\n * A generator that fails instead of ending is logged and the stream is\n * closed where it stood, so what already went out stays valid and the\n * client sees an ordinary end of stream. Letting the failure escape\n * instead would reach no one the application can hear: the platform prints\n * a raw stack and tears the connection down, and whether the bytes already\n * queued are lost with it depends on whether a macrotask happened to run\n * in between.\n */\nexport function stream(\n  ctx: BaseCtx,\n  source: (signal: AbortSignal) => AsyncGenerator<string, void, undefined>,\n  options: StreamOptions = {},\n): Response {\n  const encoder = new TextEncoder();\n  const ending = new AbortController();\n  const signal = AbortSignal.any([ctx.req.signal, ending.signal]);\n\n  const chunks = source(signal);\n\n  const startedAt = performance.now();\n\n  let beating: ReturnType<typeof setInterval> | undefined;\n  let written = 0;\n  let bytes = 0;\n  let over = false;\n\n  /**\n   * Ends the stream once, whichever path got here first.\n   *\n   * Four of them do — the generator running out, the consumer going away,\n   * the generator throwing, and a keep-alive finding the controller shut —\n   * and the summary must be reported once, not once per path.\n   */\n  const done = (reason: StreamReason): void => {\n    if (beating !== undefined) {\n      clearInterval(beating);\n\n      beating = undefined;\n    }\n\n    ending.abort();\n\n    if (over) {\n      return;\n    }\n\n    over = true;\n\n    try {\n      options.onEnd?.({\n        chunks: written,\n        bytes,\n        durationMs: Math.round((performance.now() - startedAt) * 1000) / 1000,\n        reason,\n      });\n    } catch (error) {\n      /**\n       * The response left long ago, so there is nothing to map this to and\n       * nobody to answer — the same reason the generator's own failure is\n       * printed rather than raised.\n       */\n      console.error(\"[tetsu] stream onEnd failed:\", error);\n    }\n  };\n\n  /** Writes one chunk and counts what it put on the wire. */\n  const emit = (\n    controller: ReadableStreamDefaultController<Uint8Array>,\n    chunk: string,\n  ): void => {\n    const encoded = encoder.encode(chunk);\n\n    bytes += encoded.byteLength;\n\n    controller.enqueue(encoded);\n  };\n\n  const body = new ReadableStream<Uint8Array>({\n    /**\n     * Starts the keep-alive, which is the only thing that writes on its\n     * own schedule rather than on demand.\n     *\n     * It skips a beat the consumer has no room for, by the same rule the\n     * chunks follow: a stream with a full queue is backed up, not idle,\n     * and the filler exists only to keep an idle connection from being\n     * closed by a proxy. Without the check a stalled stream would collect\n     * one every interval for as long as it stalls, which is small and\n     * unbounded — the shape of the defect this whole pull loop exists to\n     * remove, in miniature.\n     *\n     * No test separates the two: the fillers are a few bytes each and they\n     * queue behind the megabyte the transport is already holding, so\n     * nothing observable through a socket ever reaches them. The check is\n     * kept on the reasoning, not on a measurement, and this is the note\n     * saying so.\n     */\n    start(controller) {\n      const alive = options.keepAlive;\n\n      if (!alive || alive.everyMs <= 0) {\n        return;\n      }\n\n      beating = setInterval(() => {\n        if ((controller.desiredSize ?? 0) <= 0) {\n          return;\n        }\n\n        try {\n          emit(controller, alive.chunk);\n        } catch {\n          done(\"cancelled\");\n        }\n      }, alive.everyMs);\n    },\n\n    /**\n     * Produces one chunk, and only when the consumer has room for it.\n     *\n     * This is the whole of the backpressure: the platform calls `pull`\n     * while the queue wants more and stops calling it when it does not, so\n     * exactly one `next()` is ever in flight and the generator advances at\n     * the rate the client reads. Driving the generator from a loop instead\n     * asks it for everything at once, because `enqueue` never blocks and\n     * never refuses: a client that stopped reading had a million chunks\n     * built for it and held in memory.\n     *\n     * The cost of the shape is that leaving a loop no longer ends the\n     * generator, because there is no loop; `cancel` calls `return()` in\n     * its place.\n     */\n    async pull(controller) {\n      try {\n        const next = await chunks.next();\n\n        if (next.done || signal.aborted) {\n          /**\n           * The signal is checked first on purpose: a generator that takes\n           * it does the polite thing and returns, so `done` would be true\n           * on a stream the client walked away from. What ended it is the\n           * departure, and that is what the summary should say.\n           *\n           * No test separates this from always reporting `ended`, and that\n           * is not a gap in the tests. Every way the signal becomes true\n           * here runs through a `done` call that has already fixed the\n           * reason — `cancel` on the consumer's side, the keep-alive\n           * finding a shut controller — and all of them say `cancelled`\n           * too. The branch decides a race whose other outcome agrees with\n           * it, which is why it is kept and why nothing can observe it.\n           */\n          done(signal.aborted ? \"cancelled\" : \"ended\");\n          close(controller);\n\n          return;\n        }\n\n        written += 1;\n\n        emit(controller, next.value);\n      } catch (error) {\n        console.error(\"[tetsu] stream generator failed:\", error);\n\n        done(\"failed\");\n        close(controller);\n      }\n    },\n\n    /**\n     * The stream's own end of life, told by whoever consumed it.\n     *\n     * Not a backstop: this is the only thing that ends a stream whose\n     * response never reached the client. The pipeline releases a response\n     * it discards — one a `beforeResponse` hook replaced, one an error\n     * displaced, one a `HEAD` request answered without — by cancelling its\n     * body, and the request's own signal says nothing in those cases,\n     * because the request itself ended normally.\n     *\n     * A client that leaves aborts `ctx.req.signal` first, so that path\n     * does not depend on this line; the request whose response was thrown\n     * away depends on nothing else.\n     */\n    cancel() {\n      done(\"cancelled\");\n\n      void chunks.return();\n    },\n  });\n\n  return new Response(body, {\n    status: options.status ?? 200,\n    headers: {\n      ...(options.contentType\n        ? { \"content-type\": options.contentType }\n        : undefined),\n      ...options.headers,\n    },\n  });\n}\n\n/**\n * Ends the stream, tolerating a client that already left.\n *\n * `close()` throws on a controller the platform closed when the connection\n * went away, and that is not a failure worth reporting: the stream ended\n * exactly as it was going to.\n */\nfunction close(controller: ReadableStreamDefaultController<Uint8Array>): void {\n  try {\n    controller.close();\n  } catch {\n    // The stream is already closed because the client left.\n  }\n}\n",
+    "/**\n * Server-sent events.\n *\n * ```ts\n * route({\n *   method: \"GET\",\n *   path: \"/prices\",\n *   handler: (ctx) =>\n *     sse(ctx, async function* (signal) {\n *       for await (const price of prices.watch({ signal })) {\n *         yield { data: price, id: price.at };\n *       }\n *     }),\n * });\n * ```\n *\n * The framework needs none of this to stream — a handler returning a\n * `Response` with a stream already works. What this adds is the part that\n * is easy to get quietly wrong: the wire format (a blank line ends an\n * event, and every line of a multi-line payload carries its own `data:`\n * prefix), the headers a proxy needs to see, the heartbeat that keeps an\n * idle connection from being closed by one, an `AbortSignal` that says the\n * stream is over so a source that waits can stop waiting, and the\n * backpressure that makes a slow client cost a buffer rather than a heap:\n * events are produced on demand, one at a time, at the rate they are\n * read.\n *\n * @module\n */\n\nimport type { BaseCtx } from \"@tetsujs/core\";\nimport type { StreamReason, StreamSummary } from \"./stream.ts\";\nimport { stream } from \"./stream.ts\";\n\nexport type {\n  KeepAlive,\n  StreamOptions,\n  StreamReason,\n  StreamSummary,\n} from \"./stream.ts\";\nexport { stream } from \"./stream.ts\";\n\n/**\n * One event, as it goes over the wire.\n *\n * `data` is deliberately untyped. A stream usually carries several kinds\n * of event under different names, so one type parameter would be wrong for\n * all but the simplest feed — and nothing on the server consumes the\n * payload's type anyway: it leaves as JSON. A feed that is uniform can say\n * so where it is written, by typing its own generator.\n */\nexport interface ServerSentEvent {\n  /**\n   * The payload. A string is sent as it is; anything else is JSON, which\n   * is what a browser's `EventSource` expects to parse. A value JSON has\n   * no form for — `undefined`, a function, a symbol — is refused rather\n   * than sent as an empty string: a payload that went missing, a\n   * `map.get()` that found nothing, would reach the page as a valid event\n   * with nothing in it.\n   */\n  readonly data: unknown;\n\n  /** Event name, read by `addEventListener(name)` rather than `onmessage`. */\n  readonly event?: string;\n\n  /**\n   * Event id. The browser sends the last one back as `Last-Event-ID` when\n   * it reconnects, which is how a stream resumes where it stopped.\n   */\n  readonly id?: string | number;\n\n  /** How long the browser waits before reconnecting, in milliseconds. */\n  readonly retry?: number;\n}\n\n/** How the stream behaves. */\nexport interface SseOptions {\n  /**\n   * How often a comment line is sent to keep the connection alive, in\n   * milliseconds. Defaults to 15 seconds; `0` turns it off.\n   *\n   * On by default because the failure it prevents is silent and remote: a\n   * proxy between the server and the browser closes a connection that has\n   * been idle — nginx after 60 seconds by default — and the application\n   * sees a client that keeps reconnecting for no visible reason.\n   */\n  readonly heartbeatMs?: number;\n\n  /** Status of the response. `200` by default. */\n  readonly status?: number;\n\n  /**\n   * Called once when the stream is over, with what it did.\n   *\n   * The gap this closes: `afterResponse` runs when the response is handed\n   * to the runtime, which for a stream is the moment it *starts*. An\n   * access log therefore records a forty-minute feed as a `200` that took\n   * microseconds, and a torn connection as a success. Delivery to the\n   * client is not observable in the fetch model and stays that way — but\n   * the end of *generation* is, and that is what this reports.\n   *\n   * It carries no request id on purpose. This callback is written at the\n   * call site, where `ctx` is already in scope, so the caller adds\n   * whatever identifies the request better than this package could guess.\n   *\n   * @example\n   * ```ts\n   * sse(ctx, feed, {\n   *   onEnd: (summary) =>\n   *     logger.info({ ...summary, requestId: ctx.requestId }, \"stream closed\"),\n   * });\n   * ```\n   */\n  readonly onEnd?: (summary: SseSummary) => void;\n}\n\n/**\n * How an SSE stream ended — {@link StreamReason} by another name, because\n * a reader of this package should not have to go looking.\n */\nexport type SseReason = StreamReason;\n\n/**\n * One finished stream, as server-sent events count it.\n *\n * The same record {@link StreamSummary} carries, with `chunks` named\n * `events`: for this helper one chunk is one event, and the word an author\n * reads at the call site should be the one they wrote.\n */\nexport interface SseSummary extends Omit<StreamSummary, \"chunks\"> {\n  /** Events yielded and written, not counting heartbeats. */\n  readonly events: number;\n}\n\n/**\n * Builds a server-sent events response from an async generator.\n *\n * The generator is handed an `AbortSignal` that fires when the stream is\n * over, whichever way it ended — the client disconnected, the consumer\n * cancelled, the generator itself failed. It is not `ctx.req.signal`\n * directly: a source wants to know that this stream is finished, not which\n * of the ways finished it.\n *\n * **Passing it on is what makes cleanup work**, and it is the caller's job\n * rather than this package's. A generator between two `yield`s leaves on\n * its own — the loop sees the abort at the next value, ends the `for\n * await`, and the language calls the generator's `return()`, which runs\n * its `finally`. A generator parked inside an `await` is resumed by\n * nothing: `return()` on it is queued behind that `await` and applies only\n * once it settles, so an `await` on a source that has gone quiet never\n * unwinds, and the subscription inside it lives as long as the process.\n * Neither `cancel()` on the stream nor `return()` on the generator changes\n * that — both were measured, both fire, neither wakes it — which is why\n * the signal goes to the source instead.\n *\n * So the rule, stated plainly: **a stream ends with the connection if its\n * generator keeps yielding, or if it waits on the signal.** A generator\n * that does neither leaks, and no amount of care out here can collect it.\n *\n * A generator that fails instead of ending is logged and the stream is\n * closed where it stood, so what already went out stays valid and the\n * client sees an ordinary end of stream. Letting the failure escape\n * `start()` instead would reach no one the application can hear: the\n * platform prints a raw stack and tears the connection down, and whether\n * the bytes already queued are lost with it depends on whether a macrotask\n * happened to run in between.\n *\n * @example A source that yields on its own — the loop ends it.\n * ```ts\n * sse(ctx, async function* () {\n *   const subscription = topic.subscribe();\n *\n *   try {\n *     for await (const message of subscription) {\n *       yield { event: \"message\", data: message, id: message.id };\n *     }\n *   } finally {\n *     subscription.close();\n *   }\n * });\n * ```\n *\n * @example A source that can go quiet — it has to take the signal.\n * ```ts\n * sse(ctx, async function* (signal) {\n *   const queue = await broker.subscribe(\"prices\", { signal });\n *\n *   try {\n *     for await (const price of queue) {\n *       yield { data: price, id: price.at };\n *     }\n *   } finally {\n *     await queue.close();\n *   }\n * });\n * ```\n */\nexport function sse(\n  ctx: BaseCtx,\n  source: (\n    signal: AbortSignal,\n  ) => AsyncGenerator<ServerSentEvent, void, undefined>,\n  options: SseOptions = {},\n): Response {\n  const heartbeatMs = options.heartbeatMs ?? 15_000;\n\n  const { onEnd } = options;\n\n  return stream(\n    ctx,\n    /**\n     * The only part of this helper that is about server-sent events: the\n     * events become frames, and everything else — backpressure, the\n     * signal, ending the generator, the summary — is the stream's.\n     *\n     * A `for await` rather than a manual loop, because leaving it is what\n     * passes `return()` on to the source when the stream is cancelled.\n     */\n    async function* (signal) {\n      for await (const event of source(signal)) {\n        yield frame(event);\n      }\n    },\n    {\n      contentType: \"text/event-stream\",\n      headers: { \"cache-control\": \"no-cache\" },\n\n      ...(options.status === undefined ? {} : { status: options.status }),\n\n      ...(heartbeatMs > 0\n        ? { keepAlive: { everyMs: heartbeatMs, chunk: \": ping\\n\\n\" } }\n        : {}),\n\n      ...(onEnd\n        ? {\n            onEnd: ({ chunks, ...rest }: StreamSummary) =>\n              onEnd({ ...rest, events: chunks }),\n          }\n        : {}),\n    },\n  );\n}\n\n/**\n * What ends a line for a client reading this stream.\n *\n * The protocol terminates a line on CRLF, CR or LF — all three, which is\n * why splitting the payload on `\\n` alone is not enough: a lone `\\r` ends\n * the field just as surely, and the rest of the value is read as a new one.\n */\nconst lineBreak = /\\r\\n|[\\r\\n]/;\n\n/** What a single-line field cannot carry without ceasing to be one. */\nconst unrepresentable = /[\\r\\n\\0]/;\n\n/**\n * Formats one event.\n *\n * Every line of the payload carries its own `data:` prefix — a raw line\n * break inside one would otherwise end the field — and a blank line ends\n * the event, which is what makes the client dispatch it.\n */\nexport function frame(event: ServerSentEvent): string {\n  const lines: string[] = [];\n\n  if (event.event !== undefined) {\n    lines.push(`event: ${single(\"event\", event.event)}`);\n  }\n\n  if (event.id !== undefined) {\n    lines.push(`id: ${single(\"id\", String(event.id))}`);\n  }\n\n  if (event.retry !== undefined) {\n    lines.push(`retry: ${event.retry}`);\n  }\n\n  const payload =\n    typeof event.data === \"string\" ? event.data : JSON.stringify(event.data);\n\n  if (payload === undefined) {\n    throw new TypeError(\n      `an SSE event's data has no JSON form: ${typeof event.data}`,\n    );\n  }\n\n  for (const line of payload.split(lineBreak)) {\n    lines.push(`data: ${line}`);\n  }\n\n  return `${lines.join(\"\\n\")}\\n\\n`;\n}\n\n/**\n * Checks a field the protocol gives no way to continue onto a second line.\n *\n * `data` can carry a line break because every one of its lines is prefixed\n * again; `event` and `id` cannot — the protocol has no syntax for it. So a\n * value holding one is not \"an event name with a newline in it\", it is a\n * second field the client will read and act on: a name the stream never\n * sent, or an id it will send back on reconnect. That is an injection, and\n * the values most likely to hold a line break are exactly the ones built\n * from outside input — a topic name, a row's key, a user's label.\n *\n * Throwing rather than stripping, for the reason the platform throws on a\n * header value with CRLF in it: a quietly rewritten id resumes the stream\n * somewhere else, and the application never learns it asked for something\n * the wire cannot carry. NUL joins them because a client drops an `id`\n * holding one, which breaks resumption just as silently.\n */\nfunction single(field: string, value: string): string {\n  if (unrepresentable.test(value)) {\n    throw new TypeError(\n      `an SSE ${field} cannot contain a line break or NUL: ${JSON.stringify(value)}`,\n    );\n  }\n\n  return value;\n}\n\n/**\n * The id the client last received, when it is reconnecting.\n *\n * A browser sends it automatically after a dropped connection; a stream\n * that yields ids can resume from it instead of starting over.\n *\n * @example\n * ```ts\n * handler: (ctx) =>\n *   sse(ctx, async function* () {\n *     for await (const item of history.since(lastEventId(ctx))) {\n *       yield { data: item, id: item.id };\n *     }\n *   });\n * ```\n */\nexport function lastEventId(ctx: BaseCtx): string | undefined {\n  return ctx.req.headers.get(\"last-event-id\") ?? undefined;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "41A90C435B2C5A2764756E2164756E21",
+  "names": []
+}