@fishenv/http 0.0.0-stage → 0.0.3

package/dist/core/upgrade.js

@@ -0,0 +1,110 @@
+/**
+ * Generic WebSocket upgrade plumbing for Bun — deliberately protocol-agnostic
+ * so core never depends on `@fishenv/http/ws`.
+ *
+ * Bun upgrades from inside `fetch(req, server)`, but route handlers only see
+ * `req` and must return a `Response`. A handler therefore *requests* an
+ * upgrade (keyed by the `Request`, which survives CORS/HEAD response cloning)
+ * and returns a placeholder; `serve()` — or {@link completeUpgrade} for a
+ * hand-rolled `Bun.serve` — performs the actual upgrade.
+ */
+const pending = new WeakMap();
+/**
+ * Ask the server to upgrade `req` once the response pipeline finishes.
+ *
+ * The returned `426` is only ever seen when no server performs the upgrade —
+ * e.g. when calling `router.fetch()` directly in a unit test.
+ */
+export function requestUpgrade(req, intent) {
+    pending.set(req, intent);
+    return new Response("Upgrade Required", {
+        status: 426,
+        headers: { Upgrade: "websocket", Connection: "Upgrade" },
+    });
+}
+/** Remove and return the pending upgrade for `req`, if any. */
+export function takeUpgrade(req) {
+    const intent = pending.get(req);
+    if (intent != null)
+        pending.delete(req);
+    return intent;
+}
+/**
+ * Finish a request inside Bun's `fetch(req, server)`: performs a pending
+ * upgrade (returning `undefined`, as Bun requires) or passes `res` through.
+ */
+export function completeUpgrade(req, res, server) {
+    const intent = takeUpgrade(req);
+    if (intent == null)
+        return res;
+    const upgraded = server.upgrade(req, {
+        data: { handlers: intent.handlers, server, state: intent.state },
+        headers: intent.headers,
+    });
+    if (upgraded)
+        return undefined;
+    return new Response("WebSocket upgrade failed", { status: 400 });
+}
+export const DEFAULT_MAX_PAYLOAD_LENGTH = 64 * 1024;
+export const DEFAULT_BACKPRESSURE_LIMIT = 1024 * 1024;
+/** `1001 Going Away` — sent to every socket on graceful shutdown. */
+export const CLOSE_GOING_AWAY = 1001;
+/** `1011 Internal Error`. */
+export const CLOSE_INTERNAL_ERROR = 1011;
+/**
+ * Build the single Bun `websocket` handler that dispatches every event to the
+ * per-socket {@link SocketHandlers}. Also a last-resort guard: a handler that
+ * throws or rejects is logged and its socket closed with `1011`.
+ */
+export function createWebSocketRuntime(options = {}, logger) {
+    const open = new Set();
+    const log = logger ?? console;
+    const guard = (ws, event, run) => {
+        const fail = (err) => {
+            log.error(`[fishenv.http] WebSocket ${event} handler failed:`, err);
+            if (event !== "close")
+                ws.close(CLOSE_INTERNAL_ERROR, "Internal Error");
+        };
+        try {
+            const result = run();
+            if (result instanceof Promise)
+                result.catch(fail);
+        }
+        catch (err) {
+            fail(err);
+        }
+    };
+    const websocket = {
+        open(ws) {
+            open.add(ws);
+            guard(ws, "open", () => ws.data.handlers.open?.(ws));
+        },
+        message(ws, message) {
+            guard(ws, "message", () => ws.data.handlers.message?.(ws, message));
+        },
+        close(ws, code, reason) {
+            open.delete(ws);
+            guard(ws, "close", () => ws.data.handlers.close?.(ws, code, reason));
+        },
+        drain(ws) {
+            guard(ws, "drain", () => ws.data.handlers.drain?.(ws));
+        },
+        maxPayloadLength: options.maxPayloadLength ?? DEFAULT_MAX_PAYLOAD_LENGTH,
+        backpressureLimit: options.backpressureLimit ?? DEFAULT_BACKPRESSURE_LIMIT,
+        closeOnBackpressureLimit: options.closeOnBackpressureLimit ?? true,
+        idleTimeout: options.idleTimeout ?? 120,
+        sendPings: options.sendPings ?? true,
+        perMessageDeflate: options.perMessageDeflate ?? false,
+        publishToSelf: false,
+    };
+    return {
+        websocket,
+        get size() {
+            return open.size;
+        },
+        closeAll(code = CLOSE_GOING_AWAY, reason = "Server shutting down") {
+            for (const ws of [...open])
+                ws.close(code, reason);
+        },
+    };
+}

package/dist/core/utils/headers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/utils/headers.js

@@ -0,0 +1,2 @@
+// Header normalization utilities
+// TODO: implement in step 07

package/dist/core/utils/url.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Combine a base prefix and a route sub-path into one canonical path.
+ * Always returns a path starting with "/" and no trailing slash (except root).
+ */
+export declare function mergePaths(base: string, sub: string): string;
+/**
+ * Extract all named param names from a pattern (runtime, not type-level).
+ * E.g. "/users/:id/posts/:pid?/:rest*" → ["id", "pid", "rest"]
+ */
+export declare function extractParamNames(pattern: string): string[];
+/**
+ * Convert a route pattern to a regex + ordered param name list.
+ *
+ * Rules:
+ * - `:name`  → named capture `([^/]+)`
+ * - `:name?` → optional named capture `(?:/([^/]+))?`
+ * - `:name*` → rest capture `(?:/(.*))?`, last segment only. The captured
+ *              remainder is raw (percent-encoded) and keeps a trailing slash;
+ *              the param is absent when nothing follows the prefix.
+ * - `*`      → glob within a segment (`[^/]*`)
+ * - `**`     → glob across path segments
+ * - `{a,b}`  → alternation `(?:a|b)`
+ */
+export declare function buildRouteRegex(pattern: string): {
+    regex: RegExp;
+    paramNames: string[];
+};

package/dist/core/utils/url.js

@@ -0,0 +1,130 @@
+/**
+ * Combine a base prefix and a route sub-path into one canonical path.
+ * Always returns a path starting with "/" and no trailing slash (except root).
+ */
+export function mergePaths(base, sub) {
+    const combined = `${base.replace(/\/+$/, "")}/${sub.replace(/^\/+/, "")}`;
+    const normalized = `/${combined.replace(/^\/+/, "")}`.replace(/\/+$/, "") || "/";
+    return normalized;
+}
+/**
+ * Extract all named param names from a pattern (runtime, not type-level).
+ * E.g. "/users/:id/posts/:pid?/:rest*" → ["id", "pid", "rest"]
+ */
+export function extractParamNames(pattern) {
+    const names = [];
+    for (const segment of pattern.split("/")) {
+        if (segment.startsWith(":")) {
+            names.push(segment.slice(1).replace(/[?*]$/, ""));
+        }
+    }
+    return names;
+}
+/**
+ * Convert a route pattern to a regex + ordered param name list.
+ *
+ * Rules:
+ * - `:name`  → named capture `([^/]+)`
+ * - `:name?` → optional named capture `(?:/([^/]+))?`
+ * - `:name*` → rest capture `(?:/(.*))?`, last segment only. The captured
+ *              remainder is raw (percent-encoded) and keeps a trailing slash;
+ *              the param is absent when nothing follows the prefix.
+ * - `*`      → glob within a segment (`[^/]*`)
+ * - `**`     → glob across path segments
+ * - `{a,b}`  → alternation `(?:a|b)`
+ */
+export function buildRouteRegex(pattern) {
+    const paramNames = [];
+    const segments = pattern.split("/").filter((s) => s !== "");
+    let regexStr = "";
+    for (const [i, seg] of segments.entries()) {
+        if (seg.startsWith(":") && seg.endsWith("*")) {
+            if (i !== segments.length - 1) {
+                throw new Error(`Rest param "${seg}" must be the last segment of "${pattern}"`);
+            }
+            paramNames.push(seg.slice(1, -1));
+            regexStr += `(?:/(.*))?`;
+            continue;
+        }
+        if (seg.startsWith(":")) {
+            const isOptional = seg.endsWith("?");
+            const name = seg.slice(1).replace(/\?$/, "");
+            paramNames.push(name);
+            if (isOptional) {
+                regexStr += `(?:/([^/]+))?`;
+            }
+            else {
+                regexStr += `/([^/]+)`;
+            }
+            continue;
+        }
+        if (seg === "**") {
+            regexStr += `(?:/.*)?`;
+            continue;
+        }
+        regexStr += `/${globSegmentToRegex(seg)}`;
+    }
+    // Empty pattern → root
+    if (regexStr === "")
+        regexStr = "/";
+    return {
+        regex: new RegExp(`^${regexStr}$`),
+        paramNames,
+    };
+}
+function globSegmentToRegex(segment) {
+    let out = "";
+    let i = 0;
+    while (i < segment.length) {
+        const ch = segment[i];
+        if (ch === "*") {
+            out += "[^/]*";
+            i++;
+            continue;
+        }
+        if (ch === "{") {
+            const end = findClosingBrace(segment, i);
+            if (end === -1) {
+                out += "\\{";
+                i++;
+                continue;
+            }
+            const body = segment.slice(i + 1, end);
+            const parts = splitBraceParts(body).map((part) => globLiteralToRegex(part));
+            out += parts.length > 0 ? `(?:${parts.join("|")})` : "\\{\\}";
+            i = end + 1;
+            continue;
+        }
+        out += escapeRegex(ch);
+        i++;
+    }
+    return out;
+}
+function globLiteralToRegex(part) {
+    let out = "";
+    for (const ch of part) {
+        if (ch === "*") {
+            out += "[^/]*";
+        }
+        else {
+            out += escapeRegex(ch);
+        }
+    }
+    return out;
+}
+function findClosingBrace(str, start) {
+    for (let i = start + 1; i < str.length; i++) {
+        if (str[i] === "}")
+            return i;
+    }
+    return -1;
+}
+function splitBraceParts(body) {
+    return body
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/core/validation.d.ts

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+import { type ValidationField } from "./error.ts";
+import type { AnySchema } from "./types.ts";
+/**
+ * Validate a single field value against a Valibot schema.
+ * Throws ValidationError on failure.
+ */
+export declare function validateField<S extends AnySchema>(schema: S, value: unknown, field: ValidationField): v.InferOutput<S>;
+/**
+ * Validate path params: each param with a registered schema gets validated/coerced.
+ * Params without schemas pass through as raw strings.
+ */
+export declare function validatePathParams(rawParams: Record<string, string>, schemas: Map<string, AnySchema>): Record<string, unknown>;

package/dist/core/validation.js

@@ -0,0 +1,24 @@
+import * as v from "valibot";
+import { ValidationError } from "./error.js";
+/**
+ * Validate a single field value against a Valibot schema.
+ * Throws ValidationError on failure.
+ */
+export function validateField(schema, value, field) {
+    const result = v.safeParse(schema, value);
+    if (!result.success) {
+        throw new ValidationError(field, result.issues);
+    }
+    return result.output;
+}
+/**
+ * Validate path params: each param with a registered schema gets validated/coerced.
+ * Params without schemas pass through as raw strings.
+ */
+export function validatePathParams(rawParams, schemas) {
+    const validated = { ...rawParams };
+    for (const [name, schema] of schemas) {
+        validated[name] = validateField(schema, rawParams[name], "path");
+    }
+    return validated;
+}

package/dist/sse/connection.d.ts

@@ -0,0 +1,30 @@
+/** A single live SSE stream, usable beyond the lifetime of its route handler. */
+import type { SseCleanupFn, SseConnectionOptions, SseEventOptions } from "./types.ts";
+export declare const DEFAULT_HIGH_WATER_MARK: number;
+/**
+ * Every method is a no-op once the connection is closed, so a stale reference
+ * held by a service or registry can never throw.
+ */
+export declare class SseConnection {
+    #private;
+    /** Unique per connection; a user may hold several (one per tab/device). */
+    readonly id: string;
+    /** From the `Last-Event-ID` header, falling back to a `?lastEventId=` query param. */
+    readonly lastEventId: string | null;
+    readonly req: Request;
+    constructor(controller: ReadableStreamDefaultController<Uint8Array>, req: Request, options?: SseConnectionOptions);
+    get closed(): boolean;
+    /** Bytes queued but not yet flushed to the socket. */
+    get bufferedBytes(): number;
+    /** Returns `false` if the event was dropped because the connection is gone or saturated. */
+    send(data: unknown, opts?: SseEventOptions): boolean;
+    /** Send a comment line — invisible to `EventSource`, used as a heartbeat. */
+    comment(text?: string): boolean;
+    /** Tell the client how long to wait before reconnecting. */
+    retry(ms: number): boolean;
+    close(): void;
+    /** Runs immediately if the connection is already closed. */
+    onClose(fn: SseCleanupFn): void;
+}
+/** @internal */
+export declare function runCleanup(fn: SseCleanupFn): void;

package/dist/sse/connection.js

@@ -0,0 +1,104 @@
+/** A single live SSE stream, usable beyond the lifetime of its route handler. */
+import { encodeSseComment, encodeSseEvent, encodeSseRetry } from "./encode.js";
+const encoder = new TextEncoder();
+export const DEFAULT_HIGH_WATER_MARK = 64 * 1024;
+/**
+ * Every method is a no-op once the connection is closed, so a stale reference
+ * held by a service or registry can never throw.
+ */
+export class SseConnection {
+    /** Unique per connection; a user may hold several (one per tab/device). */
+    id = crypto.randomUUID();
+    /** From the `Last-Event-ID` header, falling back to a `?lastEventId=` query param. */
+    lastEventId;
+    req;
+    #controller;
+    #highWaterMark;
+    #overflow;
+    #closed = false;
+    #closeCallbacks = [];
+    constructor(controller, req, options = {}) {
+        this.#controller = controller;
+        this.req = req;
+        this.#highWaterMark = options.highWaterMark ?? DEFAULT_HIGH_WATER_MARK;
+        this.#overflow = options.onOverflow ?? "close";
+        this.lastEventId =
+            req.headers.get("last-event-id") ??
+                new URL(req.url).searchParams.get("lastEventId");
+    }
+    get closed() {
+        return this.#closed;
+    }
+    /** Bytes queued but not yet flushed to the socket. */
+    get bufferedBytes() {
+        if (this.#closed || this.#controller == null)
+            return 0;
+        return this.#highWaterMark - (this.#controller.desiredSize ?? 0);
+    }
+    /** Returns `false` if the event was dropped because the connection is gone or saturated. */
+    send(data, opts) {
+        return this.#write(encodeSseEvent(data, opts));
+    }
+    /** Send a comment line — invisible to `EventSource`, used as a heartbeat. */
+    comment(text = "") {
+        return this.#write(encodeSseComment(text));
+    }
+    /** Tell the client how long to wait before reconnecting. */
+    retry(ms) {
+        return this.#write(encodeSseRetry(ms));
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        const controller = this.#controller;
+        this.#controller = null;
+        try {
+            controller?.close();
+        }
+        catch {
+            // Already closed or errored by the consumer — nothing to do.
+        }
+        const callbacks = this.#closeCallbacks;
+        this.#closeCallbacks = [];
+        for (const cb of callbacks)
+            runCleanup(cb);
+    }
+    /** Runs immediately if the connection is already closed. */
+    onClose(fn) {
+        if (this.#closed) {
+            runCleanup(fn);
+            return;
+        }
+        this.#closeCallbacks.push(fn);
+    }
+    #write(frame) {
+        if (this.#closed || this.#controller == null)
+            return false;
+        if ((this.#controller.desiredSize ?? 0) <= 0) {
+            if (this.#overflow === "close")
+                this.close();
+            return false;
+        }
+        try {
+            this.#controller.enqueue(encoder.encode(frame));
+            return true;
+        }
+        catch {
+            this.close();
+            return false;
+        }
+    }
+}
+/** @internal */
+export function runCleanup(fn) {
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            result.catch((err) => console.error("[fishenv.sse] close callback rejected:", err));
+        }
+    }
+    catch (err) {
+        console.error("[fishenv.sse] close callback threw:", err);
+    }
+}

package/dist/sse/encode.d.ts

@@ -0,0 +1,10 @@
+/** SSE wire format — turning values into `text/event-stream` frames. */
+import type { SseEventOptions } from "./types.ts";
+/** Field values are attacker-reachable; CR/LF/NUL would forge extra frames. */
+export declare function sanitizeField(value: string): string;
+/** Serialize a value into a complete SSE frame (including the terminating blank line). */
+export declare function encodeSseEvent(data: unknown, opts?: SseEventOptions): string;
+/** A standalone `retry:` frame, sent without any accompanying data. */
+export declare function encodeSseRetry(ms: number): string;
+/** A comment frame — invisible to `EventSource`, used as a heartbeat. */
+export declare function encodeSseComment(text: string): string;

package/dist/sse/encode.js

@@ -0,0 +1,27 @@
+/** SSE wire format — turning values into `text/event-stream` frames. */
+/** Field values are attacker-reachable; CR/LF/NUL would forge extra frames. */
+export function sanitizeField(value) {
+    return value.replace(/[\r\n\0]/g, "");
+}
+/** Serialize a value into a complete SSE frame (including the terminating blank line). */
+export function encodeSseEvent(data, opts) {
+    let frame = "";
+    if (opts?.id != null)
+        frame += `id: ${sanitizeField(opts.id)}\n`;
+    if (opts?.event != null)
+        frame += `event: ${sanitizeField(opts.event)}\n`;
+    if (opts?.retry != null)
+        frame += `retry: ${Math.trunc(opts.retry)}\n`;
+    const text = typeof data === "string" ? data : (JSON.stringify(data) ?? "");
+    for (const line of text.split(/\r\n|\r|\n/))
+        frame += `data: ${line}\n`;
+    return `${frame}\n`;
+}
+/** A standalone `retry:` frame, sent without any accompanying data. */
+export function encodeSseRetry(ms) {
+    return `retry: ${Math.trunc(ms)}\n\n`;
+}
+/** A comment frame — invisible to `EventSource`, used as a heartbeat. */
+export function encodeSseComment(text) {
+    return `: ${sanitizeField(text)}\n\n`;
+}

package/dist/sse/hub.d.ts

@@ -0,0 +1,33 @@
+/** Keyed registry of live connections — the seam for targeted (non-broadcast) sends. */
+import type { SseConnection } from "./connection.ts";
+import type { SseEventOptions, SseHubOptions } from "./types.ts";
+/**
+ * Connections keyed by an application identifier (user id, tenant id, document
+ * id…). One key maps to many connections.
+ *
+ * Subclass it to get a DI token:
+ * ```ts
+ * class UserEvents extends SseHub {}
+ * ```
+ */
+export declare class SseHub {
+    #private;
+    constructor(options?: SseHubOptions);
+    /** Register a connection. Returns an unregister fn; also auto-removes on close. */
+    add(key: string, connection: SseConnection): () => void;
+    /** Push to every connection registered under `key`. Returns local delivery count. */
+    send(key: string, data: unknown, opts?: SseEventOptions): number;
+    /** Push to every connection under any of `keys`. Returns local delivery count. */
+    sendMany(keys: Iterable<string>, data: unknown, opts?: SseEventOptions): number;
+    /** Push to every connection in this hub. Returns local delivery count. */
+    broadcast(data: unknown, opts?: SseEventOptions): number;
+    /** Close every connection under `key`. Returns how many were closed. */
+    close(key: string): number;
+    /** Close every connection and detach the transport subscription. */
+    closeAll(): void;
+    has(key: string): boolean;
+    /** Connection count for `key`, or the hub total when `key` is omitted. */
+    count(key?: string): number;
+    keys(): string[];
+    connections(key: string): SseConnection[];
+}

package/dist/sse/hub.js

@@ -0,0 +1,115 @@
+/** Keyed registry of live connections — the seam for targeted (non-broadcast) sends. */
+import { createTransportBridge, } from "../core/transport.js";
+/**
+ * Connections keyed by an application identifier (user id, tenant id, document
+ * id…). One key maps to many connections.
+ *
+ * Subclass it to get a DI token:
+ * ```ts
+ * class UserEvents extends SseHub {}
+ * ```
+ */
+export class SseHub {
+    #byKey = new Map();
+    #bridge;
+    constructor(options = {}) {
+        this.#bridge = createTransportBridge(options.transport, (message) => this.#deliver(message.key, message.data, {
+            event: message.event,
+            id: message.id,
+            retry: message.retry,
+        }), { label: "[fishenv.sse]" });
+    }
+    /** Register a connection. Returns an unregister fn; also auto-removes on close. */
+    add(key, connection) {
+        let set = this.#byKey.get(key);
+        if (set == null) {
+            set = new Set();
+            this.#byKey.set(key, set);
+        }
+        set.add(connection);
+        const remove = () => {
+            const current = this.#byKey.get(key);
+            if (current == null)
+                return;
+            current.delete(connection);
+            if (current.size === 0)
+                this.#byKey.delete(key);
+        };
+        connection.onClose(remove);
+        return remove;
+    }
+    /** Push to every connection registered under `key`. Returns local delivery count. */
+    send(key, data, opts) {
+        this.#publish(key, data, opts);
+        return this.#deliver(key, data, opts);
+    }
+    /** Push to every connection under any of `keys`. Returns local delivery count. */
+    sendMany(keys, data, opts) {
+        let delivered = 0;
+        for (const key of keys)
+            delivered += this.send(key, data, opts);
+        return delivered;
+    }
+    /** Push to every connection in this hub. Returns local delivery count. */
+    broadcast(data, opts) {
+        this.#publish(null, data, opts);
+        return this.#deliver(null, data, opts);
+    }
+    /** Close every connection under `key`. Returns how many were closed. */
+    close(key) {
+        const set = this.#byKey.get(key);
+        if (set == null)
+            return 0;
+        const connections = [...set];
+        for (const connection of connections)
+            connection.close();
+        return connections.length;
+    }
+    /** Close every connection and detach the transport subscription. */
+    closeAll() {
+        for (const set of [...this.#byKey.values()]) {
+            for (const connection of [...set])
+                connection.close();
+        }
+        this.#byKey.clear();
+        this.#bridge.close();
+    }
+    has(key) {
+        return (this.#byKey.get(key)?.size ?? 0) > 0;
+    }
+    /** Connection count for `key`, or the hub total when `key` is omitted. */
+    count(key) {
+        if (key != null)
+            return this.#byKey.get(key)?.size ?? 0;
+        let total = 0;
+        for (const set of this.#byKey.values())
+            total += set.size;
+        return total;
+    }
+    keys() {
+        return [...this.#byKey.keys()];
+    }
+    connections(key) {
+        return [...(this.#byKey.get(key) ?? [])];
+    }
+    #deliver(key, data, opts) {
+        const targets = key == null
+            ? [...this.#byKey.values()].flatMap((set) => [...set])
+            : [...(this.#byKey.get(key) ?? [])];
+        let delivered = 0;
+        for (const connection of targets) {
+            if (connection.send(data, opts))
+                delivered++;
+        }
+        return delivered;
+    }
+    #publish(key, data, opts) {
+        this.#bridge.publish({
+            key,
+            data,
+            event: opts?.event,
+            id: opts?.id,
+            retry: opts?.retry,
+        });
+    }
+}

package/dist/sse/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Server-Sent Events for `@fishenv/http`.
+ *
+ * An SSE route is an ordinary `GET` route whose handler returns a streaming
+ * `Response`, so middleware, path-param validation, interceptors and the error
+ * chain all work unchanged — no core dispatch branching is required.
+ *
+ * Live connections can be registered in an {@link SseHub} so that any service
+ * can push to a specific client later:
+ *
+ * ```ts
+ * class UserEvents extends SseHub {}
+ *
+ * api.sse("/events").keepalive(30_000).subscribe(UserEvents, ({ ctx }) => ctx.user.id);
+ *
+ * // elsewhere, e.g. inside a use case
+ * userEvents.send(userId, { type: "order.shipped" }, { event: "notification" });
+ * ```
+ *
+ * Module layout:
+ * - `types.ts`         — shared data types
+ * - `encode.ts`        — `text/event-stream` framing
+ * - `connection.ts`    — `SseConnection`, a single live stream
+ * - `response.ts`      — `createSseResponse()`, request → streaming response
+ * - `hub.ts`           — `SseHub`, keyed registry for targeted sends
+ * - `route-builder.ts` — `SseRouteBuilder`
+ * - `router.ts`        — `withSse()` mixin
+ */
+export { SseConnection } from "./connection.ts";
+export { encodeSseComment, encodeSseEvent, encodeSseRetry } from "./encode.ts";
+export { SseHub } from "./hub.ts";
+export type { SseOpenFn } from "./response.ts";
+export { createSseResponse } from "./response.ts";
+export type { SseHandlerArgs, SseHandlerFn } from "./route-builder.ts";
+export { SseRouteBuilder } from "./route-builder.ts";
+export type { SseRouter } from "./router.ts";
+export { withSse } from "./router.ts";
+export type { SseCleanupFn, SseConnectionOptions, SseEventOptions, SseHubOptions, SseOverflowPolicy, SseTransport, SseTransportMessage, } from "./types.ts";