@fishenv/http 0.0.0-stage → 0.0.2

package/dist/core/router.js

@@ -0,0 +1,288 @@
+import { dispatch } from "./compose.js";
+import { buildCors } from "./cors.js";
+import { defaultMethodNotAllowedHandler, defaultNotFoundHandler, } from "./error.js";
+import { Matcher } from "./matcher.js";
+import { createRouteBuilder, createRouteBuilderFromContract, } from "./route-builder.js";
+const stubContainer = {
+    get() {
+        throw new Error("No DI container configured. Pass one via serve() options.");
+    },
+};
+/**
+ * Router — immutable middleware chain, mutable route registration.
+ *
+ * `.use()` returns a new Router with the extended Ctx type but the same
+ * backing store — routes registered on either instance are collected together.
+ * Route methods (.get, .post, etc.) return a RouteBuilder chain.
+ * Call `.build()` before `.fetch` or `serve()`.
+ *
+ * `Requires` is the context this router expects a parent to provide when it
+ * is mounted via `.add()`. Create one with `r<AppCtx>()`; `.add()` only
+ * accepts it on a parent whose `Ctx` satisfies `AppCtx`, and `serve()` only
+ * accepts routers with no outstanding requirements.
+ */
+export class Router {
+    #prefix;
+    #middlewares;
+    #store;
+    #errorHandler;
+    #notFoundHandler;
+    #cors = null;
+    #built = false;
+    #matcher = null;
+    #container = stubContainer;
+    constructor(opts, middlewares, errorHandler, notFoundHandler, store) {
+        this.#prefix = opts?.prefix ?? "";
+        this.#middlewares = middlewares ?? [];
+        this.#errorHandler = errorHandler;
+        this.#notFoundHandler = notFoundHandler;
+        this.#store = store ?? { routes: [], children: [], locked: false };
+    }
+    // ── RouterRef implementation ─────────────────────────────────────────
+    _registerRoute(def) {
+        if (this.#store.locked) {
+            throw new Error("Cannot add routes after build()");
+        }
+        this.#store.routes.push(def);
+    }
+    _getMiddlewares() {
+        return [...this.#middlewares];
+    }
+    _getPrefix() {
+        return this.#prefix;
+    }
+    // ── Middleware ────────────────────────────────────────────────────────
+    use(mw) {
+        return new Router({ prefix: this.#prefix }, [
+            ...this.#middlewares,
+            mw,
+        ], this.#errorHandler, this.#notFoundHandler, this.#store);
+    }
+    // ── Sub-router ───────────────────────────────────────────────────────
+    /** Create a child router and mount it on this one — shorthand for `r<Ctx>(opts)` + `.add()`. */
+    extend(opts) {
+        const child = new Router(opts);
+        this.add(child);
+        return child;
+    }
+    add(...args) {
+        if (this.#store.locked) {
+            throw new Error("Cannot add routers after build()");
+        }
+        const extra = typeof args[0] === "string" ? args.shift() : "";
+        for (const child of args) {
+            this.#store.children.push({
+                router: child,
+                prefix: this.#prefix + extra,
+                middlewares: [...this.#middlewares],
+            });
+        }
+        return this;
+    }
+    // ── Route methods ────────────────────────────────────────────────────
+    get(path) {
+        return createRouteBuilder(this, "GET", path);
+    }
+    post(path) {
+        return createRouteBuilder(this, "POST", path);
+    }
+    put(path) {
+        return createRouteBuilder(this, "PUT", path);
+    }
+    patch(path) {
+        return createRouteBuilder(this, "PATCH", path);
+    }
+    delete(path) {
+        return createRouteBuilder(this, "DELETE", path);
+    }
+    options(path) {
+        return createRouteBuilder(this, "OPTIONS", path);
+    }
+    // ── Contract-driven route ────────────────────────────────────────────
+    /**
+     * Register a route from a `@fishenv/http-contract` endpoint definition, e.g.:
+     *
+     * ```ts
+     * router.contract(contract.users.create).handle(({ body }) => { ... });
+     * ```
+     *
+     * `.handle()` gets exactly the same type safety (body/query/params/output)
+     * as chaining `.input().output().param()` manually, because the contract
+     * endpoint and the route builder share the same shape types.
+     */
+    contract(endpoint) {
+        return createRouteBuilderFromContract(this, endpoint);
+    }
+    // ── Error / not-found ────────────────────────────────────────────────
+    // ── CORS ─────────────────────────────────────────────────────────────
+    cors(options) {
+        this.#cors = buildCors(options);
+        return this;
+    }
+    // ── Error / not-found ────────────────────────────────────────────────
+    onError(handler) {
+        this.#errorHandler = handler;
+        return this;
+    }
+    notFound(handler) {
+        this.#notFoundHandler = handler;
+        return this;
+    }
+    // ── Container ────────────────────────────────────────────────────────
+    /** @internal Set by serve(). For testing, call before build(). */
+    _setContainer(container) {
+        this.#container = container;
+    }
+    // ── Build ────────────────────────────────────────────────────────────
+    build() {
+        if (this.#built)
+            return; // idempotent
+        const matcher = new Matcher();
+        const allRoutes = this.#collectRoutes();
+        for (const route of allRoutes) {
+            matcher.add(route.method, route.path, route);
+        }
+        matcher.compile();
+        this.#matcher = matcher;
+        this.#built = true;
+        this.#store.locked = true;
+    }
+    // ── Fetch ────────────────────────────────────────────────────────────
+    /**
+     * Entry point for request handling — available after build().
+     * Use directly for testing without binding a port.
+     */
+    fetch = async (req) => {
+        if (!this.#built || !this.#matcher) {
+            throw new Error("Router not built. Call .build() first.");
+        }
+        const url = new URL(req.url);
+        const method = req.method.toUpperCase();
+        const isHead = method === "HEAD";
+        // CORS preflight — short-circuit before route matching
+        if (method === "OPTIONS" && this.#cors) {
+            return this.#cors.preflight(req);
+        }
+        // Try exact method match, then HEAD→GET fallback
+        let matched = this.#matcher.match(method, url.pathname);
+        if (isHead && (!matched || matched.allowedMethods)) {
+            const getMatch = this.#matcher.match("GET", url.pathname);
+            if (getMatch && !getMatch.allowedMethods) {
+                matched = getMatch;
+            }
+        }
+        if (!matched) {
+            const notFound = this.#notFoundHandler ?? defaultNotFoundHandler;
+            return notFound(req);
+        }
+        // 405 — path matched but method didn't
+        if (matched.allowedMethods) {
+            const allowed = isHead && !matched.allowedMethods.includes("HEAD")
+                ? [...matched.allowedMethods, "HEAD"]
+                : matched.allowedMethods;
+            return defaultMethodNotAllowedHandler(req, allowed);
+        }
+        // Build error handler chain: route catch → router onError → default
+        const errorHandlers = [];
+        if (matched.definition.errorHandler) {
+            errorHandlers.push(matched.definition.errorHandler);
+        }
+        if (matched.definition.routerErrorHandlers) {
+            errorHandlers.push(...matched.definition.routerErrorHandlers);
+        }
+        if (this.#errorHandler) {
+            errorHandlers.push(this.#errorHandler);
+        }
+        let response = await dispatch(req, matched.definition, matched.params, this.#container, errorHandlers);
+        // Inject CORS headers on every response
+        if (this.#cors) {
+            response = this.#cors.applyTo(req, response);
+        }
+        // HEAD: strip body
+        if (isHead) {
+            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
+     * copied (a child may be mounted more than once) with the mount prefix and
+     * middleware prepended and the child's onError appended to the chain.
+     * Locks every visited store.
+     */
+    #collectRoutes(visiting = new Set()) {
+        if (visiting.has(this.#store)) {
+            throw new Error("Router mount cycle detected");
+        }
+        visiting.add(this.#store);
+        this.#store.locked = true;
+        const routes = [...this.#store.routes];
+        for (const { router: child, prefix, middlewares } of this.#store.children) {
+            if (child.#cors || child.#notFoundHandler) {
+                throw new Error("cors() and notFound() are only supported on the root router");
+            }
+            for (const def of child.#collectRoutes(visiting)) {
+                routes.push({
+                    ...def,
+                    path: prefix + def.path,
+                    middlewares: [...middlewares, ...def.middlewares],
+                    routerErrorHandlers: child.#errorHandler
+                        ? [...(def.routerErrorHandlers ?? []), child.#errorHandler]
+                        : def.routerErrorHandlers,
+                });
+            }
+        }
+        visiting.delete(this.#store);
+        return routes;
+    }
+}
+// ── Factories ────────────────────────────────────────────────────────────
+/**
+ * Create a router. Pass a context type to declare what a parent must provide
+ * when this router is mounted with `.add()`:
+ *
+ * ```ts
+ * // context.ts
+ * export const base = r().use(auth);
+ * export type AppCtx = CtxOf<typeof base>;
+ *
+ * // users.ts — type-only import, no runtime cycle
+ * export const users = r<AppCtx>({ prefix: "/users" });
+ *
+ * // main.ts
+ * serve(base.add(users));
+ * ```
+ */
+export function r(opts) {
+    return new Router(opts);
+}
+export const router = r;
+export function serve(
+// biome-ignore lint/suspicious/noExplicitAny: accepts routers of any context
+app, options) {
+    if (options?.container) {
+        app._setContainer(options.container);
+    }
+    app.build(); // idempotent
+    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),
+    });
+    const handle = {
+        hostname: server.hostname ?? options?.hostname ?? "0.0.0.0",
+        port: server.port ?? options?.port ?? 8000,
+        stop: (force) => server.stop(force),
+    };
+    options?.signal?.addEventListener("abort", () => void handle.stop(), {
+        once: true,
+    });
+    options?.onListen?.({ hostname: handle.hostname, port: handle.port });
+    return handle;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The "shape" types (schemas, input/output, params, HTTP method, route meta)
+ * live in `@fishenv/http-contract` so that a `ContractBuilder` and a `RouteBuilder`
+ * are built from exactly the same type definitions — no structural-typing
+ * gap between `router.contract(endpoint).handle(...)` and
+ * `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";
+export interface ResolvedInput<K extends InputKind, O extends InputOptions<K>> {
+    kind: K;
+    options: O;
+}
+export type MiddlewareFn<In extends object, Out extends object> = (ctx: In & {
+    req: Request;
+}) => Promise<Out> | Out;
+export type MergeCtx<A extends Record<string, unknown>, B extends Record<string, unknown>> = A & B;
+export type InterceptorState = Record<string, unknown>;
+export type BeforeInterceptorFn<Ctx extends Record<string, unknown>> = (args: {
+    req: Request;
+    ctx: Ctx;
+    state: InterceptorState;
+}) => Promise<void> | void;
+export type AfterInterceptorFn<Ctx extends Record<string, unknown>> = (args: {
+    response: Response;
+    ctx: Ctx;
+    state: InterceptorState;
+}) => Promise<Response> | Response;
+export interface InterceptorPair<Ctx extends Record<string, unknown>> {
+    before?: BeforeInterceptorFn<Ctx>;
+    after?: AfterInterceptorFn<Ctx>;
+}
+export interface HandlerArgs<Ctx extends Record<string, unknown>, K extends InputKind, O extends InputOptions<K>, Params extends Record<string, unknown>> {
+    req: Request;
+    path: Params;
+    ctx: Ctx;
+    body: InferBody<K, O>;
+    headers: InferHeaders<O>;
+    query: InferQuery<O>;
+    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 ErrorHandlerFn = (err: unknown, args: {
+    req: Request;
+}) => Response | Promise<Response> | null | undefined | void;
+export interface RouteDefinition {
+    method: HttpMethod;
+    path: string;
+    middlewares: MiddlewareFn<Record<string, unknown>, Record<string, unknown>>[];
+    paramSchemas: Map<string, AnySchema>;
+    inputKind: InputKind;
+    inputOptions: InputOptions<InputKind>;
+    outputSchema?: AnySchema;
+    errorTypes?: (new (...args: unknown[]) => Error)[];
+    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[];
+    kind: "http" | "ws" | "sse";
+}
+export interface DIContainer {
+    get<T>(token: abstract new (...args: any[]) => T): T;
+}
+export type NotFoundHandler = (req: Request) => Response | Promise<Response>;

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,24 @@
+/**
+ * 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?" → ["id", "pid"]
+ */
+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 `(?:/([^/]+))?`
+ * - `*`      → 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,119 @@
+/**
+ * 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?" → ["id", "pid"]
+ */
+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 `(?:/([^/]+))?`
+ * - `*`      → 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 seg of segments) {
+        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);
+    }
+}