@c9up/ream 0.1.3

package/dist/http/Response.js

@@ -0,0 +1,303 @@
+/**
+ * Response — accumulates HTTP response state with a fluent API.
+ *
+ * Wraps the same { status, headers, body } wire format expected by the NAPI layer.
+ * Provides AdonisJS-compatible methods: json(), send(), status(), header(), etc.
+ *
+ * @implements FR21
+ */
+import { openSseStream, } from './SseStream.js';
+/**
+ * Reject CR / LF / NUL bytes in header names or values. Without this guard
+ * an attacker controlling part of a header (e.g. a redirect URL parameter
+ * echoed into `Location`) could splice extra response headers — the classic
+ * CRLF injection / response-splitting attack (CWE-113).
+ */
+function assertNoCRLF(name, value) {
+    if (/[\r\n\0]/.test(name) || /[\r\n\0]/.test(value)) {
+        throw new Error(`CRLF / NUL byte in header '${name}' is not allowed (response-splitting protection).`);
+    }
+}
+export class Response {
+    #status = 200;
+    #headers = {};
+    #cookies = [];
+    #body = '';
+    #finished = false;
+    #redirectBuilderFactory;
+    #streamBackend;
+    #streamId;
+    /**
+     * CSP nonce for this request (AdonisJS idiom: `response.nonce`). Seeded by
+     * the `@c9up/blackhole` middleware when the CSP uses `@nonce`; `undefined`
+     * otherwise. Also published to `ctx.store` as `cspNonce` for templating.
+     */
+    nonce;
+    // ─── Status ───────────────────────────────────────────────
+    /** Set the HTTP status code. Chainable. */
+    status(code) {
+        this.#status = code;
+        return this;
+    }
+    /** Set status only if not already set (still 200). */
+    safeStatus(code) {
+        if (this.#status === 200) {
+            this.#status = code;
+        }
+        return this;
+    }
+    // ─── Headers ──────────────────────────────────────────────
+    /** Set a response header. Chainable. */
+    header(key, value) {
+        assertNoCRLF(key, value);
+        this.#headers[key.toLowerCase()] = value;
+        return this;
+    }
+    /** Append to a response header (for multi-value like Set-Cookie). */
+    append(key, value) {
+        assertNoCRLF(key, value);
+        const k = key.toLowerCase();
+        if (k === 'set-cookie') {
+            // Set-Cookie must NOT be comma-joined — each cookie is its own
+            // header line, or browsers/proxies mis-parse the lot. Route into
+            // the same `#cookies` channel `cookie()` uses; `getHeaders()`
+            // emits them newline-separated for the serializer.
+            this.#cookies.push(value);
+            return this;
+        }
+        const existing = this.#headers[k];
+        this.#headers[k] = existing ? `${existing}, ${value}` : value;
+        return this;
+    }
+    /** Remove a response header. */
+    removeHeader(key) {
+        delete this.#headers[key.toLowerCase()];
+        return this;
+    }
+    /** Set the Content-Type header. Chainable. */
+    type(contentType) {
+        // Same CRLF/NUL guard as header() — `type(userValue)` must not be a
+        // response-splitting hole just because it writes a fixed header key.
+        assertNoCRLF('content-type', contentType);
+        this.#headers['content-type'] = contentType;
+        return this;
+    }
+    // ─── Body ─────────────────────────────────────────────────
+    /** Send a JSON response. Sets content-type and stringifies. */
+    json(data) {
+        this.#headers['content-type'] = 'application/json';
+        this.#body = JSON.stringify(data);
+        this.#finished = true;
+    }
+    /** Send a response body. Auto-detects content type if not set. */
+    send(data) {
+        if (typeof data === 'string') {
+            if (!this.#headers['content-type']) {
+                this.#headers['content-type'] = 'text/html; charset=utf-8';
+            }
+            this.#body = data;
+        }
+        else if (Buffer.isBuffer(data)) {
+            // Without this branch a Buffer would hit the `typeof === 'object'`
+            // path and be JSON-stringified into `{"type":"Buffer","data":[...]}`
+            // — every binary asset (PNG, PDF, ...) would arrive corrupted.
+            this.sendBuffer(data);
+            return;
+        }
+        else if (typeof data === 'object' && data !== null) {
+            this.#headers['content-type'] = 'application/json';
+            this.#body = JSON.stringify(data);
+        }
+        else if (data !== undefined && data !== null) {
+            if (!this.#headers['content-type']) {
+                this.#headers['content-type'] = 'text/plain';
+            }
+            this.#body = String(data);
+        }
+        this.#finished = true;
+    }
+    /**
+     * Send a binary body as-is. Encodes to base64 across the NAPI bridge
+     * with the `x-ream-body-encoding: base64` marker so the Rust HTTP
+     * layer decodes it before writing to the socket. The marker header is
+     * stripped server-side and never leaks to the client.
+     *
+     * Use this for any non-UTF-8 payload (images, PDFs, archives, etc.) —
+     * `send()` auto-routes Buffers here, but call directly when intent is
+     * unambiguous.
+     */
+    sendBuffer(buffer) {
+        if (!this.#headers['content-type']) {
+            this.#headers['content-type'] = 'application/octet-stream';
+        }
+        this.#headers['x-ream-body-encoding'] = 'base64';
+        this.#body = buffer.toString('base64');
+        this.#finished = true;
+    }
+    /** Send 204 No Content. */
+    noContent() {
+        this.#status = 204;
+        this.#body = '';
+        this.#finished = true;
+    }
+    // ─── Redirect ─────────────────────────────────────────────
+    /** Get a redirect builder. */
+    redirect() {
+        if (this.#redirectBuilderFactory) {
+            return this.#redirectBuilderFactory();
+        }
+        throw new Error('redirect() requires an HttpContext. Response was created outside a request handler.');
+    }
+    /** @internal Set the redirect builder factory (injected by HttpContext). */
+    setRedirectFactory(factory) {
+        this.#redirectBuilderFactory = factory;
+    }
+    /** @internal Wire the SSE backend (HyperServer NAPI). Injected by HttpKernel. */
+    setStreamBackend(backend) {
+        this.#streamBackend = backend;
+    }
+    // ─── Streaming (SSE) ──────────────────────────────────────
+    /**
+     * Open a Server-Sent Events stream. The returned `SseStream` lets the
+     * handler push named events for as long as the client stays
+     * connected. Headers are pre-set to the SSE wire format; the host
+     * router serializes the response with the reserved stream id so the
+     * Rust HyperServer keeps the connection open.
+     *
+     *   const sse = await ctx.response.sse()
+     *   sse.send('connected', { uid: caller.id })
+     *   onTaskAssigned((evt) => sse.send('task.assigned', evt))
+     *
+     * Throws `STREAMING_UNSUPPORTED` if the underlying HyperServer host
+     * does not implement the streaming NAPI (e.g. a mock server in unit
+     * tests). The host capability is opt-in: implement
+     * `registerStream`/`writeStream`/`closeStream`/`onStreamDisconnect`
+     * to participate.
+     */
+    async sse(options) {
+        if (!this.#streamBackend) {
+            throw new Error('[ream] response.sse() requires a streaming-capable HyperServer host. ' +
+                'The current server has no stream backend wired.');
+        }
+        // SSE wire format + safety defaults. The buffered body string stays
+        // empty — every chunk goes through the registry instead.
+        this.#headers['content-type'] = 'text/event-stream';
+        if (!this.#headers['cache-control']) {
+            this.#headers['cache-control'] = 'no-cache, no-transform';
+        }
+        if (!this.#headers['x-accel-buffering']) {
+            this.#headers['x-accel-buffering'] = 'no';
+        }
+        const stream = await openSseStream(this.#streamBackend, options);
+        this.#streamId = stream.id;
+        // Mark the response as "finished" so middleware that bails when
+        // `isFinished()` is true (the standard short-circuit) doesn't
+        // re-touch the body or headers after the SSE pipe has been set up.
+        this.#finished = true;
+        return stream;
+    }
+    // ─── Cookies ──────────────────────────────────────────────
+    /** Set a response cookie. */
+    cookie(name, value, options) {
+        // SameSite=None cookies REQUIRE the Secure attribute — modern browsers
+        // (Chrome 80+, Firefox, Safari) silently reject the cookie otherwise, so
+        // a missing Secure here turns OAuth callbacks / iframe sessions into a
+        // "works in dev (localhost relaxes Secure), breaks in prod" foot-gun.
+        if (options?.sameSite === 'none' && !options.secure) {
+            throw new Error(`Cookie '${name}': SameSite=None requires Secure: true (browsers reject SameSite=None cookies without Secure).`);
+        }
+        const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+        // `maxAge: 0` is the RFC 6265 "delete-now" signal used by logout
+        // flows. A truthiness check would skip it and leave the cookie
+        // alive for the session — explicit `!== undefined` covers both
+        // 0 and negative values that browsers also treat as immediate
+        // expiry.
+        if (options?.maxAge !== undefined)
+            parts.push(`Max-Age=${options.maxAge}`);
+        if (options?.path) {
+            // `Path` is concatenated raw (encodeURIComponent would mangle the `/`
+            // separators a path legitimately contains), so it needs the same
+            // CRLF/NUL guard as header()/append() — otherwise a controlled path
+            // injects into the `\n`-joined Set-Cookie header (response-splitting).
+            assertNoCRLF(`Set-Cookie path for '${name}'`, options.path);
+            parts.push(`Path=${options.path}`);
+        }
+        if (options?.httpOnly !== false)
+            parts.push('HttpOnly');
+        if (options?.secure)
+            parts.push('Secure');
+        if (options?.sameSite)
+            parts.push(`SameSite=${options.sameSite}`);
+        this.#cookies.push(parts.join('; '));
+        return this;
+    }
+    // ─── Internals (used by HttpKernel for NAPI serialization) ─
+    /** @internal Get the accumulated status code. */
+    getStatus() {
+        return this.#status;
+    }
+    /** @internal Get all accumulated headers (Set-Cookie as separate entries joined by newline). */
+    getHeaders() {
+        const headers = { ...this.#headers };
+        if (this.#cookies.length > 0) {
+            // Multiple Set-Cookie headers must be separate — we join with \n for the serializer
+            headers['set-cookie'] = this.#cookies.join('\n');
+        }
+        return headers;
+    }
+    /**
+     * Read a single accumulated response header by name (case-insensitive).
+     * Returns `undefined` when not set — used by middleware that conditionally
+     * inspects the outgoing content-type before sanitisation.
+     */
+    getHeader(name) {
+        return this.#headers[name.toLowerCase()];
+    }
+    /** @internal Get the accumulated body string. */
+    getBody() {
+        return this.#body;
+    }
+    /** @internal Check if response has been finalized. */
+    isFinished() {
+        return this.#finished;
+    }
+    /** @internal Set body directly (used by redirect, exception handler). */
+    setBody(body) {
+        this.#body = body;
+        this.#finished = true;
+    }
+    /**
+     * @internal Streaming-response handle, set by `sse()`. The host
+     * router forwards this id to the Rust HyperServer so the connection
+     * stays open and chunks flow from the JS-side writer.
+     */
+    getStreamId() {
+        return this.#streamId;
+    }
+    /**
+     * @internal Tear down a stream the handler opened via `sse()` but
+     * then abandoned by throwing. Closes the backend registry slot and
+     * clears the stream id + finished flag so the kernel's error path
+     * serializes a normal buffered error response instead of emitting
+     * `streamId` alongside an error body (which would leave the
+     * HyperServer feeding a dead/empty stream forever). Best-effort: a
+     * closeStream failure is swallowed — the slot's TTL/disconnect will
+     * reclaim it.
+     */
+    async abortStream() {
+        const id = this.#streamId;
+        if (id === undefined)
+            return;
+        this.#streamId = undefined;
+        this.#finished = false;
+        if (this.#streamBackend) {
+            try {
+                await this.#streamBackend.closeStream(id);
+            }
+            catch {
+                // benign — registry TTL / client disconnect reclaims the slot.
+            }
+        }
+    }
+}
+//# sourceMappingURL=Response.js.map

package/dist/http/Response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Response.js","sourceRoot":"","sources":["../../src/http/Response.ts"],"names":[],"mappings":"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"}

package/dist/http/SseStream.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Server-Sent Events writer — owns one logical SSE stream and pushes
+ * encoded events through the underlying `StreamBackend` (a thin
+ * abstraction over the HyperServer NAPI `registerStream` / `writeStream`
+ * / `closeStream` trio).
+ *
+ * Lifecycle:
+ *
+ *   1. `ctx.response.sse()` returns a ready-to-use writer. Internally it
+ *      asks the backend to reserve a stream id and stamps the response
+ *      with the right `Content-Type` + caching headers so the host
+ *      router knows to switch into streaming mode.
+ *   2. The handler calls `writer.send(event, data)` / `writer.comment(...)`
+ *      to push frames. Each call returns a boolean — `false` once the
+ *      client has disconnected, so callers can bail out of long loops
+ *      without polling.
+ *   3. The handler RETURNS the Response from the route — buffered body is
+ *      empty, but `response.getStreamId()` is set, so Ream tells the
+ *      Rust HyperServer to keep the connection open and feed the body
+ *      from the stream registry.
+ *   4. Background tasks keep pushing through `writer.send(...)` until
+ *      either the client leaves (`onClose` callback fires) or the
+ *      server calls `writer.end()`.
+ *
+ * The encoding follows the SSE wire format (RFC chez WHATWG):
+ *
+ *     event: <name>\n
+ *     data: <stringified payload>\n
+ *     id: <optional event id>\n
+ *     \n
+ *
+ * Multi-line payloads are split on `\n` and each line is prefixed with
+ * `data: ` so the consumer browser reassembles them with newlines.
+ */
+/** Minimal backend the writer needs — the HyperServer NAPI fits exactly. */
+export interface StreamBackend {
+    registerStream(streamId: string): Promise<boolean>;
+    writeStream(streamId: string, chunk: string): Promise<boolean>;
+    closeStream(streamId: string): Promise<boolean>;
+    onStreamDisconnect(streamId: string, callback: () => void): void;
+}
+export interface SseStreamOptions {
+    /** Keep-alive ping interval (ms). Defaults to 30s. Set to 0 to disable. */
+    pingInterval?: number;
+    /** Initial `retry: <ms>` directive sent before any event. Defaults to 5_000. */
+    retry?: number;
+}
+/** Active SSE writer returned by `response.sse()`. */
+export declare class SseStream {
+    #private;
+    readonly id: string;
+    constructor(id: string, backend: StreamBackend, options?: SseStreamOptions);
+    /** True until the client disconnects or the server calls `end()`. */
+    isOpen(): boolean;
+    /**
+     * Send a named SSE event. `data` is JSON-stringified unless it is
+     * already a string. Returns `false` if the stream is closed.
+     *
+     * `eventId` is optional — set it when you want browsers to send
+     * `Last-Event-ID` on reconnection. Useful for resumable streams.
+     */
+    send(event: string, data: unknown, eventId?: string): Promise<boolean>;
+    /**
+     * Send a comment frame (`:text\n\n`) — useful for keep-alives and
+     * for human-readable inline debug. Comments are NOT delivered to
+     * `EventSource.onmessage`; the browser silently consumes them.
+     */
+    comment(text: string): Promise<boolean>;
+    /** Register a callback fired once the underlying connection drops. */
+    onClose(callback: () => void): void;
+    /**
+     * End the stream from the server side. Idempotent. The matching
+     * NAPI receiver finishes its work and hyper closes the body.
+     */
+    end(): Promise<void>;
+}
+/**
+ * Open a new SSE stream against the given backend. Returns once the
+ * registry slot is reserved — safe to call `send()` immediately, even
+ * before the handler has returned (frames buffer in the bounded mpsc
+ * inside Rust).
+ *
+ * The `retry: <ms>` directive is sent as the first thing on the wire
+ * (a comment frame would be invisible to the client; the retry hint
+ * needs to land before any real event so browsers know how long to
+ * wait before reconnecting if the connection drops).
+ */
+export declare function openSseStream(backend: StreamBackend, options?: SseStreamOptions): Promise<SseStream>;
+//# sourceMappingURL=SseStream.d.ts.map

package/dist/http/SseStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SseStream.d.ts","sourceRoot":"","sources":["../../src/http/SseStream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC5B,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAClD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC9D,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC/C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;CACjE;AAED,MAAM,WAAW,gBAAgB;IAC/B,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAeD,sDAAsD;AACtD,qBAAa,SAAS;;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;gBAOP,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,gBAAgB;IA2C1E,qEAAqE;IACrE,MAAM,IAAI,OAAO;IAIjB;;;;;;OAMG;IACG,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAM5E;;;;OAIG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ7C,sEAAsE;IACtE,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAcnC;;;OAGG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAgC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,SAAS,CAAC,CAapB"}

package/dist/http/SseStream.js

@@ -0,0 +1,228 @@
+/**
+ * Server-Sent Events writer — owns one logical SSE stream and pushes
+ * encoded events through the underlying `StreamBackend` (a thin
+ * abstraction over the HyperServer NAPI `registerStream` / `writeStream`
+ * / `closeStream` trio).
+ *
+ * Lifecycle:
+ *
+ *   1. `ctx.response.sse()` returns a ready-to-use writer. Internally it
+ *      asks the backend to reserve a stream id and stamps the response
+ *      with the right `Content-Type` + caching headers so the host
+ *      router knows to switch into streaming mode.
+ *   2. The handler calls `writer.send(event, data)` / `writer.comment(...)`
+ *      to push frames. Each call returns a boolean — `false` once the
+ *      client has disconnected, so callers can bail out of long loops
+ *      without polling.
+ *   3. The handler RETURNS the Response from the route — buffered body is
+ *      empty, but `response.getStreamId()` is set, so Ream tells the
+ *      Rust HyperServer to keep the connection open and feed the body
+ *      from the stream registry.
+ *   4. Background tasks keep pushing through `writer.send(...)` until
+ *      either the client leaves (`onClose` callback fires) or the
+ *      server calls `writer.end()`.
+ *
+ * The encoding follows the SSE wire format (RFC chez WHATWG):
+ *
+ *     event: <name>\n
+ *     data: <stringified payload>\n
+ *     id: <optional event id>\n
+ *     \n
+ *
+ * Multi-line payloads are split on `\n` and each line is prefixed with
+ * `data: ` so the consumer browser reassembles them with newlines.
+ */
+const DEFAULT_PING_INTERVAL = 30_000;
+const DEFAULT_RETRY = 5_000;
+/** Cryptographic-quality stream id — 16 random bytes, hex-encoded. */
+function generateStreamId() {
+    const bytes = new Uint8Array(16);
+    // `crypto.getRandomValues` is the WHATWG primitive available on every
+    // supported Node version (>=22). Avoids pulling in `node:crypto` for
+    // a 32-char hex string.
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+}
+/** Active SSE writer returned by `response.sse()`. */
+export class SseStream {
+    id;
+    #backend;
+    #open = true;
+    #closeFired = false;
+    #pingTimer = null;
+    #closeListeners = [];
+    constructor(id, backend, options) {
+        this.id = id;
+        this.#backend = backend;
+        // The backend disconnect signal and a server-side end() can BOTH
+        // fire (e.g. server end() followed by the client-drop signal). The
+        // shared #fireClose() guards idempotency so user cleanups run once.
+        backend.onStreamDisconnect(id, () => {
+            this.#open = false;
+            this.#stopPing();
+            this.#fireClose();
+        });
+        const ping = options?.pingInterval ?? DEFAULT_PING_INTERVAL;
+        if (ping > 0) {
+            this.#pingTimer = setInterval(() => {
+                if (!this.#open)
+                    return;
+                // Comment frames keep the connection alive without firing a
+                // JS event on the client. `writeStream` returns false once the
+                // client has disconnected (per the NAPI contract); if we see
+                // that while still "open" the disconnect signal was missed —
+                // e.g. the client dropped in the window between registerStream
+                // and the constructor wiring onStreamDisconnect. Self-heal:
+                // stop the timer and run close listeners once, so a dropped-
+                // at-open stream can't leave an orphaned keepalive ticking
+                // against a dead registry slot.
+                void this.#backend.writeStream(this.id, ':keepalive\n\n').then((ok) => {
+                    if (!ok && this.#open) {
+                        this.#open = false;
+                        this.#stopPing();
+                        this.#fireClose();
+                    }
+                });
+            }, ping);
+            // The keepalive must not pin the Node event loop — letting the
+            // process exit on its own when nothing else is keeping it busy
+            // matches Adonis Transmit's behavior.
+            if (typeof this.#pingTimer === 'object' && 'unref' in this.#pingTimer) {
+                ;
+                this.#pingTimer.unref();
+            }
+        }
+    }
+    /** True until the client disconnects or the server calls `end()`. */
+    isOpen() {
+        return this.#open;
+    }
+    /**
+     * Send a named SSE event. `data` is JSON-stringified unless it is
+     * already a string. Returns `false` if the stream is closed.
+     *
+     * `eventId` is optional — set it when you want browsers to send
+     * `Last-Event-ID` on reconnection. Useful for resumable streams.
+     */
+    async send(event, data, eventId) {
+        if (!this.#open)
+            return false;
+        const payload = typeof data === 'string' ? data : JSON.stringify(data);
+        return this.#backend.writeStream(this.id, encodeFrame(event, payload, eventId));
+    }
+    /**
+     * Send a comment frame (`:text\n\n`) — useful for keep-alives and
+     * for human-readable inline debug. Comments are NOT delivered to
+     * `EventSource.onmessage`; the browser silently consumes them.
+     */
+    async comment(text) {
+        if (!this.#open)
+            return false;
+        // Strip newlines so a malicious comment cannot inject `\n\n` and
+        // close a frame early.
+        const sanitized = text.replace(/[\r\n]+/g, ' ');
+        return this.#backend.writeStream(this.id, `:${sanitized}\n\n`);
+    }
+    /** Register a callback fired once the underlying connection drops. */
+    onClose(callback) {
+        if (!this.#open) {
+            // Already closed — run the callback synchronously so behavior
+            // matches the standard observer pattern.
+            try {
+                callback();
+            }
+            catch {
+                // Swallow — same isolation as the normal listener loop.
+            }
+            return;
+        }
+        this.#closeListeners.push(callback);
+    }
+    /**
+     * End the stream from the server side. Idempotent. The matching
+     * NAPI receiver finishes its work and hyper closes the body.
+     */
+    async end() {
+        if (!this.#open)
+            return;
+        this.#open = false;
+        this.#stopPing();
+        await this.#backend.closeStream(this.id);
+        this.#fireClose();
+    }
+    #stopPing() {
+        if (this.#pingTimer !== null) {
+            clearInterval(this.#pingTimer);
+            this.#pingTimer = null;
+        }
+    }
+    /**
+     * Run every close listener exactly once. Both end() (server-side) and
+     * the backend disconnect signal funnel through here; the #closeFired
+     * latch stops user cleanups from being replayed when both fire.
+     */
+    #fireClose() {
+        if (this.#closeFired)
+            return;
+        this.#closeFired = true;
+        for (const cb of this.#closeListeners) {
+            try {
+                cb();
+            }
+            catch {
+                // Listener errors are isolated — one bad cleanup callback
+                // mustn't take down the rest.
+            }
+        }
+    }
+}
+/**
+ * Open a new SSE stream against the given backend. Returns once the
+ * registry slot is reserved — safe to call `send()` immediately, even
+ * before the handler has returned (frames buffer in the bounded mpsc
+ * inside Rust).
+ *
+ * The `retry: <ms>` directive is sent as the first thing on the wire
+ * (a comment frame would be invisible to the client; the retry hint
+ * needs to land before any real event so browsers know how long to
+ * wait before reconnecting if the connection drops).
+ */
+export async function openSseStream(backend, options) {
+    const id = generateStreamId();
+    const registered = await backend.registerStream(id);
+    if (!registered) {
+        // Hex collision is astronomically improbable, but surfacing it
+        // cleanly beats a silent stream-id mismatch (the response builder
+        // would then 500 with E_STREAM_UNKNOWN, which is far less helpful).
+        throw new Error(`[ream] failed to reserve SSE stream id ${id} — collision in the registry`);
+    }
+    // First frame: the recommended retry hint. Conforms to the EventSource
+    // reconnection backoff spec; falling through with the default 5s.
+    await backend.writeStream(id, `retry: ${options?.retry ?? DEFAULT_RETRY}\n\n`);
+    return new SseStream(id, backend, options);
+}
+/** Encode a single SSE event in the wire format. */
+function encodeFrame(event, data, eventId) {
+    // `event:` line first if we have a name (a frame without `event:` is
+    // delivered as a generic `message` event by the browser — both forms
+    // are valid).
+    const lines = [];
+    // `event:` and `id:` are single-line tokens — strip CR/LF so a
+    // caller-supplied event name or id can't splice extra SSE frames
+    // (the same injection `comment()` guards against). `data` is safe:
+    // it's split on `\n` and each line re-prefixed, so newlines there
+    // stay inside one logical event.
+    if (event)
+        lines.push(`event: ${event.replace(/[\r\n]+/g, ' ')}`);
+    // Multi-line data is allowed by SSE but each line must repeat the
+    // `data: ` prefix. Splitting on `\n` keeps the browser's
+    // reassembly intact (it joins back with `\n`).
+    for (const line of data.split('\n')) {
+        lines.push(`data: ${line}`);
+    }
+    if (eventId)
+        lines.push(`id: ${eventId.replace(/[\r\n]+/g, ' ')}`);
+    // Trailing blank line terminates the event.
+    return `${lines.join('\n')}\n\n`;
+}
+//# sourceMappingURL=SseStream.js.map

package/dist/http/SseStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SseStream.js","sourceRoot":"","sources":["../../src/http/SseStream.ts"],"names":[],"mappings":"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"}

package/dist/http/urlDecode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Safe URL decoding helpers for untrusted request inputs.
+ */
+/** Decode URI component and keep raw value on malformed escapes. */
+export declare function safeDecodeURIComponent(value: string): string;
+/** Decode x-www-form-urlencoded component (`+` => space) safely. */
+export declare function safeDecodeFormComponent(value: string): string;
+//# sourceMappingURL=urlDecode.d.ts.map

package/dist/http/urlDecode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlDecode.d.ts","sourceRoot":"","sources":["../../src/http/urlDecode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,oEAAoE;AACpE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM5D;AAED,oEAAoE;AACpE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG7D"}