@fishenv/http 0.0.2 → 0.0.3

package/dist/core/router.d.ts

@@ -1,7 +1,8 @@
 import type { AnyContractBuilder, ContractShape } from "../contract/index.ts";
 import { type CorsOptions } from "./cors.ts";
 import { type RouteBuilder, type RouterRef } from "./route-builder.ts";
-import type { BasePathParams, DIContainer, ErrorHandlerFn, InputOptions, MiddlewareFn, NotFoundHandler, RouteDefinition } from "./types.ts";
+import type { BasePathParams, BuildEnv, DIContainer, ErrorHandlerFn, InputOptions, MiddlewareFn, NotFoundHandler, RouteDefinition } from "./types.ts";
+import { type WsServerOptions } from "./upgrade.ts";
 type AnyRouter = Router<any, any>;
 /**
  * A router mounted via `.add()`, together with the prefix and middleware of
@@ -86,12 +87,20 @@ export declare class Router<Ctx extends Record<string, unknown> = Record<never,
     notFound(handler: NotFoundHandler): this;
     /** @internal Set by serve(). For testing, call before build(). */
     _setContainer(container: DIContainer): void;
+    /** @internal Set by serve() before build(); forwarded to route `onBuild` hooks. */
+    _setEnv(env: Partial<Omit<BuildEnv, "cors">>): void;
     build(): void;
     /**
      * Entry point for request handling — available after build().
      * Use directly for testing without binding a port.
      */
     readonly fetch: (req: Request) => Promise<Response>;
+    /**
+     * @internal Used by serve(): HEAD responses keep their body so Bun can
+     * derive `Content-Length` from it before dropping it (it does not drain
+     * streams to do so).
+     */
+    readonly _serverFetch: (req: Request) => Promise<Response>;
 }
 /**
  * Create a router. Pass a context type to declare what a parent must provide
@@ -127,6 +136,8 @@ export interface ServeOptions {
      * (disabled) so long-lived SSE streams are not cut between keepalives.
      */
     idleTimeout?: number;
+    /** Server-wide WebSocket settings (secure defaults; see {@link WsServerOptions}). */
+    websocket?: WsServerOptions;
     onListen?: (addr: {
         hostname: string;
         port: number;
@@ -136,7 +147,10 @@ export interface ServeOptions {
 export interface HttpServer {
     readonly hostname: string;
     readonly port: number;
-    /** Stop accepting connections; `force` also closes in-flight ones. */
+    /**
+     * Stop accepting connections; `force` also closes in-flight ones. Open
+     * WebSockets are always closed with `1001 Going Away` first.
+     */
     stop(force?: boolean): Promise<void>;
 }
 export interface Logger {

package/dist/core/router.js

@@ -3,6 +3,7 @@ import { buildCors } from "./cors.js";
 import { defaultMethodNotAllowedHandler, defaultNotFoundHandler, } from "./error.js";
 import { Matcher } from "./matcher.js";
 import { createRouteBuilder, createRouteBuilderFromContract, } from "./route-builder.js";
+import { completeUpgrade, createWebSocketRuntime, } from "./upgrade.js";
 const stubContainer = {
     get() {
         throw new Error("No DI container configured. Pass one via serve() options.");
@@ -28,6 +29,12 @@ export class Router {
     #errorHandler;
     #notFoundHandler;
     #cors = null;
+    #corsOptions = null;
+    #env = {
+        development: false,
+        logger: console,
+        websocket: {},
+    };
     #built = false;
     #matcher = null;
     #container = stubContainer;
@@ -117,6 +124,7 @@ export class Router {
     // ── CORS ─────────────────────────────────────────────────────────────
     cors(options) {
         this.#cors = buildCors(options);
+        this.#corsOptions = options;
         return this;
     }
     // ── Error / not-found ────────────────────────────────────────────────
@@ -133,13 +141,19 @@ export class Router {
     _setContainer(container) {
         this.#container = container;
     }
+    /** @internal Set by serve() before build(); forwarded to route `onBuild` hooks. */
+    _setEnv(env) {
+        this.#env = { ...this.#env, ...env };
+    }
     // ── Build ────────────────────────────────────────────────────────────
     build() {
         if (this.#built)
             return; // idempotent
         const matcher = new Matcher();
         const allRoutes = this.#collectRoutes();
+        const env = { ...this.#env, cors: this.#corsOptions };
         for (const route of allRoutes) {
+            route.onBuild?.(env);
             matcher.add(route.method, route.path, route);
         }
         matcher.compile();
@@ -152,7 +166,14 @@ export class Router {
      * Entry point for request handling — available after build().
      * Use directly for testing without binding a port.
      */
-    fetch = async (req) => {
+    fetch = (req) => this.#handle(req, true);
+    /**
+     * @internal Used by serve(): HEAD responses keep their body so Bun can
+     * derive `Content-Length` from it before dropping it (it does not drain
+     * streams to do so).
+     */
+    _serverFetch = (req) => this.#handle(req, false);
+    async #handle(req, stripHeadBody) {
         if (!this.#built || !this.#matcher) {
             throw new Error("Router not built. Call .build() first.");
         }
@@ -198,15 +219,16 @@ export class Router {
         if (this.#cors) {
             response = this.#cors.applyTo(req, response);
         }
-        // HEAD: strip body
-        if (isHead) {
+        // HEAD: strip body. Cancel it so a stream (e.g. SSE) is not left open.
+        if (isHead && stripHeadBody) {
+            response.body?.cancel().catch(() => { });
             return new Response(null, {
                 status: response.status,
                 headers: response.headers,
             });
         }
         return response;
-    };
+    }
     // ── Internal ─────────────────────────────────────────────────────────
     /**
      * Flatten this router's routes plus all mounted children. Child routes are
@@ -267,18 +289,35 @@ app, options) {
     if (options?.container) {
         app._setContainer(options.container);
     }
+    app._setEnv({
+        development: options?.development ?? false,
+        logger: options?.logger ?? console,
+        websocket: options?.websocket ?? {},
+    });
     app.build(); // idempotent
+    const sockets = createWebSocketRuntime(options?.websocket, options?.logger);
     const server = Bun.serve({
         port: options?.port ?? 8000,
         hostname: options?.hostname ?? "0.0.0.0",
         development: options?.development ?? false,
         idleTimeout: options?.idleTimeout ?? 0,
-        fetch: (req) => app.fetch(req),
+        fetch: async (req, server) => completeUpgrade(req, await app._serverFetch(req), server),
+        websocket: sockets.websocket,
+        // Errors outside the router's error chain (e.g. a `Bun.file` body that
+        // fails to open while the response is sent) would otherwise reach Bun's
+        // default error page, which exposes messages and paths in development.
+        error: (err) => {
+            options?.logger?.error("Unhandled error while serving request", err);
+            return new Response(null, { status: 500 });
+        },
     });
     const handle = {
         hostname: server.hostname ?? options?.hostname ?? "0.0.0.0",
         port: server.port ?? options?.port ?? 8000,
-        stop: (force) => server.stop(force),
+        stop: (force) => {
+            sockets.closeAll();
+            return server.stop(force);
+        },
     };
     options?.signal?.addEventListener("abort", () => void handle.stop(), {
         once: true,

package/dist/core/transport.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Cross-process fan-out seam shared by `@fishenv/http/sse` and
+ * `@fishenv/http/ws`. One adapter (Redis pub/sub, NATS, Postgres LISTEN…)
+ * serves both.
+ */
+import type { Logger } from "./router.ts";
+/** Every message carries the node that published it, for echo suppression. */
+export interface TransportEnvelope {
+    origin: string;
+}
+/** Messages must be JSON-serializable. */
+export interface Transport<M extends TransportEnvelope = TransportEnvelope> {
+    publish(message: M): void | Promise<void>;
+    subscribe(onMessage: (message: M) => void): () => void;
+}
+/** `Omit` that preserves discriminated unions. */
+export type WithoutOrigin<M> = M extends unknown ? Omit<M, "origin"> : never;
+export interface TransportBridge<M extends TransportEnvelope> {
+    /** Random per-process id stamped into `origin`. */
+    readonly nodeId: string;
+    /** Stamp `origin` and publish; failures are logged, never thrown. */
+    publish(message: WithoutOrigin<M>): void;
+    /** Detach from the transport. Idempotent. */
+    close(): void;
+}
+/**
+ * Wrap a (possibly absent) transport with the bookkeeping every hub needs:
+ * a node id, dropping our own echoes, and logging publish failures so a
+ * flaky broker can never break a local send.
+ */
+export declare function createTransportBridge<M extends TransportEnvelope>(transport: Transport<M> | undefined, onRemote: (message: M) => void, opts?: {
+    label?: string;
+    logger?: Pick<Logger, "error">;
+}): TransportBridge<M>;
+/**
+ * In-process transport: every subscriber sees every message. Useful for
+ * tests and for wiring several hubs together in one process.
+ */
+export declare function createMemoryTransport<M extends TransportEnvelope = TransportEnvelope>(): Transport<M>;

package/dist/core/transport.js

@@ -0,0 +1,68 @@
+/**
+ * Cross-process fan-out seam shared by `@fishenv/http/sse` and
+ * `@fishenv/http/ws`. One adapter (Redis pub/sub, NATS, Postgres LISTEN…)
+ * serves both.
+ */
+/**
+ * Wrap a (possibly absent) transport with the bookkeeping every hub needs:
+ * a node id, dropping our own echoes, and logging publish failures so a
+ * flaky broker can never break a local send.
+ */
+export function createTransportBridge(transport, onRemote, opts = {}) {
+    const nodeId = crypto.randomUUID();
+    const label = opts.label ?? "[fishenv.http]";
+    const logger = opts.logger ?? console;
+    const fail = (err) => logger.error(`${label} transport publish failed:`, err);
+    let unsubscribe = transport?.subscribe((message) => {
+        if (message.origin === nodeId)
+            return;
+        try {
+            onRemote(message);
+        }
+        catch (err) {
+            logger.error(`${label} transport message handler failed:`, err);
+        }
+    });
+    return {
+        nodeId,
+        publish(message) {
+            if (transport == null)
+                return;
+            try {
+                const result = transport.publish({
+                    ...message,
+                    origin: nodeId,
+                });
+                if (result instanceof Promise)
+                    result.catch(fail);
+            }
+            catch (err) {
+                fail(err);
+            }
+        },
+        close() {
+            unsubscribe?.();
+            unsubscribe = undefined;
+        },
+    };
+}
+/**
+ * In-process transport: every subscriber sees every message. Useful for
+ * tests and for wiring several hubs together in one process.
+ */
+export function createMemoryTransport() {
+    const subscribers = new Set();
+    return {
+        publish(message) {
+            // Clone through JSON to catch non-serializable payloads early, like a
+            // real broker would.
+            const copy = JSON.parse(JSON.stringify(message));
+            for (const fn of [...subscribers])
+                fn(copy);
+        },
+        subscribe(fn) {
+            subscribers.add(fn);
+            return () => subscribers.delete(fn);
+        },
+    };
+}

package/dist/core/types.d.ts

@@ -6,7 +6,10 @@
  * `router.post(path).input(...).output(...).handle(...)`.
  */
 export type { AnySchema, BasePathParams, ExtractParams, HttpMethod, InferBody, InferCookies, InferHeaders, InferOutput, InferQuery, InputKind, InputOptions, MergeParam, RouteMeta, ValibotSchema, } from "../contract/index.ts";
-import type { AnySchema, HttpMethod, InferBody, InferCookies, InferHeaders, InferQuery, InputKind, InputOptions, RouteMeta } from "../contract/index.ts";
+import type { AnySchema, ErrorTypes, HttpMethod, InferBody, InferCookies, InferHeaders, InferQuery, InputKind, InputOptions, RouteMeta } from "../contract/index.ts";
+import type { CorsOptions } from "./cors.ts";
+import type { Logger } from "./router.ts";
+import type { WsServerOptions } from "./upgrade.ts";
 export interface ResolvedInput<K extends InputKind, O extends InputOptions<K>> {
     kind: K;
     options: O;
@@ -40,7 +43,7 @@ export interface HandlerArgs<Ctx extends Record<string, unknown>, K extends Inpu
     cookies: InferCookies<O>;
     container: DIContainer;
 }
-export type HandlerFn<Ctx extends Record<string, unknown>, K extends InputKind, O extends InputOptions<K>, Params extends Record<string, unknown>, Output> = (args: HandlerArgs<Ctx, K, O, Params>) => Output extends unknown ? Response | Promise<Response> : Response | Output | Promise<Response | Output>;
+export type HandlerFn<Ctx extends Record<string, unknown>, K extends InputKind, O extends InputOptions<K>, Params extends Record<string, unknown>, Output> = (args: HandlerArgs<Ctx, K, O, Params>) => [Output] extends [undefined] ? Response | Promise<Response> : Response | Output | Promise<Response | Output>;
 export type ErrorHandlerFn = (err: unknown, args: {
     req: Request;
 }) => Response | Promise<Response> | null | undefined | void;
@@ -52,15 +55,31 @@ export interface RouteDefinition {
     inputKind: InputKind;
     inputOptions: InputOptions<InputKind>;
     outputSchema?: AnySchema;
-    errorTypes?: (new (...args: unknown[]) => Error)[];
+    errorTypes?: ErrorTypes;
     meta?: RouteMeta;
     interceptors: InterceptorPair<Record<string, unknown>>[];
     handler: HandlerFn<Record<string, unknown>, InputKind, InputOptions<InputKind>, Record<string, unknown>, unknown>;
     errorHandler?: ErrorHandlerFn;
     /** onError handlers of mounted routers, innermost first. Set at build(). */
     routerErrorHandlers?: ErrorHandlerFn[];
+    /**
+     * Run before *any* middleware (router-level included); throw to reject.
+     * Errors go through the normal error chain.
+     */
+    guards?: RouteGuardFn[];
+    /** Called once per route at `build()` with root-level configuration. */
+    onBuild?: (env: BuildEnv) => void;
     kind: "http" | "ws" | "sse";
 }
+export type RouteGuardFn = (req: Request) => void | Promise<void>;
+/** Root-level configuration handed to {@link RouteDefinition.onBuild}. */
+export interface BuildEnv {
+    /** The root router's `cors()` options, if configured. */
+    cors: CorsOptions | null;
+    development: boolean;
+    logger: Logger;
+    websocket: WsServerOptions;
+}
 export interface DIContainer {
     get<T>(token: abstract new (...args: any[]) => T): T;
 }

package/dist/core/upgrade.d.ts

@@ -0,0 +1,85 @@
+/**
+ * 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.
+ */
+import type { Server, ServerWebSocket, WebSocketHandler } from "bun";
+import type { Logger } from "./router.ts";
+export type UpgradedSocket = ServerWebSocket<SocketData>;
+/** Per-socket lifecycle callbacks, dispatched through `ws.data`. */
+export interface SocketHandlers {
+    open?(ws: UpgradedSocket): void | Promise<void>;
+    message?(ws: UpgradedSocket, message: string | Buffer): void | Promise<void>;
+    close?(ws: UpgradedSocket, code: number, reason: string): void | Promise<void>;
+    drain?(ws: UpgradedSocket): void;
+}
+export interface SocketData {
+    readonly handlers: SocketHandlers;
+    /** The server that owns this socket — needed for native `publish()`. */
+    readonly server: Server<SocketData>;
+    /** Owned by whoever requested the upgrade. */
+    state: unknown;
+}
+export interface UpgradeIntent {
+    handlers: SocketHandlers;
+    state?: unknown;
+    /** Extra handshake response headers, e.g. `Sec-WebSocket-Protocol`. */
+    headers?: HeadersInit;
+}
+/**
+ * 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 declare function requestUpgrade(req: Request, intent: UpgradeIntent): Response;
+/** Remove and return the pending upgrade for `req`, if any. */
+export declare function takeUpgrade(req: Request): UpgradeIntent | undefined;
+/**
+ * Finish a request inside Bun's `fetch(req, server)`: performs a pending
+ * upgrade (returning `undefined`, as Bun requires) or passes `res` through.
+ */
+export declare function completeUpgrade(req: Request, res: Response, server: Server<SocketData>): Response | undefined;
+/**
+ * Server-global socket settings. Bun's own defaults are permissive (16 MB
+ * frames and send buffers, slow consumers never dropped); these are not.
+ */
+export interface WsServerOptions {
+    /** Max inbound message size in bytes. Default 64 KiB. */
+    maxPayloadLength?: number;
+    /** Max bytes buffered per socket before backpressure. Default 1 MiB. */
+    backpressureLimit?: number;
+    /** Close sockets that exceed `backpressureLimit`. Default `true`. */
+    closeOnBackpressureLimit?: boolean;
+    /** Seconds without traffic before a socket is closed. Default 120. */
+    idleTimeout?: number;
+    /** Send protocol pings so idle-but-alive sockets stay open. Default `true`. */
+    sendPings?: boolean;
+    /** `permessage-deflate`. Default `false` (decompression-bomb surface). */
+    perMessageDeflate?: boolean;
+}
+export declare const DEFAULT_MAX_PAYLOAD_LENGTH: number;
+export declare const DEFAULT_BACKPRESSURE_LIMIT: number;
+/** `1001 Going Away` — sent to every socket on graceful shutdown. */
+export declare const CLOSE_GOING_AWAY = 1001;
+/** `1011 Internal Error`. */
+export declare const CLOSE_INTERNAL_ERROR = 1011;
+export interface WebSocketRuntime {
+    /** Pass as `websocket` to `Bun.serve`. */
+    readonly websocket: WebSocketHandler<SocketData>;
+    /** Number of sockets currently open on this server. */
+    readonly size: number;
+    /** Close every open socket, e.g. before `server.stop()`. */
+    closeAll(code?: number, reason?: string): void;
+}
+/**
+ * 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 declare function createWebSocketRuntime(options?: WsServerOptions, logger?: Pick<Logger, "error">): WebSocketRuntime;

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/url.d.ts

@@ -5,7 +5,7 @@
 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?" → ["id", "pid"]
+ * E.g. "/users/:id/posts/:pid?/:rest*" → ["id", "pid", "rest"]
  */
 export declare function extractParamNames(pattern: string): string[];
 /**
@@ -14,6 +14,9 @@ export declare function extractParamNames(pattern: string): string[];
  * 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)`

package/dist/core/utils/url.js

@@ -9,13 +9,13 @@ export function mergePaths(base, sub) {
 }
 /**
  * Extract all named param names from a pattern (runtime, not type-level).
- * E.g. "/users/:id/posts/:pid?" → ["id", "pid"]
+ * 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(/\?$/, ""));
+            names.push(segment.slice(1).replace(/[?*]$/, ""));
         }
     }
     return names;
@@ -26,6 +26,9 @@ export function extractParamNames(pattern) {
  * 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)`
@@ -34,7 +37,15 @@ export function buildRouteRegex(pattern) {
     const paramNames = [];
     const segments = pattern.split("/").filter((s) => s !== "");
     let regexStr = "";
-    for (const seg of segments) {
+    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(/\?$/, "");

package/dist/sse/hub.js

@@ -1,4 +1,5 @@
 /** 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.
@@ -10,20 +11,13 @@
  */
 export class SseHub {
     #byKey = new Map();
-    #nodeId = crypto.randomUUID();
-    #transport;
-    #unsubscribe;
+    #bridge;
     constructor(options = {}) {
-        this.#transport = options.transport;
-        this.#unsubscribe = options.transport?.subscribe((message) => {
-            if (message.origin === this.#nodeId)
-                return;
-            this.#deliver(message.key, message.data, {
-                event: message.event,
-                id: message.id,
-                retry: message.retry,
-            });
-        });
+        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) {
@@ -78,8 +72,7 @@ export class SseHub {
                 connection.close();
         }
         this.#byKey.clear();
-        this.#unsubscribe?.();
-        this.#unsubscribe = undefined;
+        this.#bridge.close();
     }
     has(key) {
         return (this.#byKey.get(key)?.size ?? 0) > 0;
@@ -111,23 +104,12 @@ export class SseHub {
         return delivered;
     }
     #publish(key, data, opts) {
-        if (this.#transport == null)
-            return;
-        try {
-            const result = this.#transport.publish({
-                key,
-                data,
-                event: opts?.event,
-                id: opts?.id,
-                retry: opts?.retry,
-                origin: this.#nodeId,
-            });
-            if (result instanceof Promise) {
-                result.catch((err) => console.error("[fishenv.sse] transport publish failed:", err));
-            }
-        }
-        catch (err) {
-            console.error("[fishenv.sse] transport publish failed:", err);
-        }
+        this.#bridge.publish({
+            key,
+            data,
+            event: opts?.event,
+            id: opts?.id,
+            retry: opts?.retry,
+        });
     }
 }