@textjs/app 0.0.0-stage → 1.0.3

package/dist/mcp/session.js

@@ -0,0 +1,742 @@
+/**
+ * A headless Text.js app session for `text mcp`: the `app/` directory mounted
+ * in-process (same route manifest and in-process route handlers as `text run`,
+ * memory history), rendered into an offscreen cell grid and driven with keys.
+ *
+ * Frame pacing is deterministic for agents: every input waits for the app to
+ * go idle — no scheduled frame, no in-flight `fetch`, and no commit or frame
+ * for `quietMs` — before the frame is read.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createElement } from "react";
+import { ATTR_INVERSE, ATTR_WIDE_CONT, initYoga, InputEngine } from "@textjs/core";
+import { createConsoleRootSync } from "@textjs/react";
+import { createMemoryHistory } from "../history.js";
+import { isNavigationError } from "../navigation-errors.js";
+import { AppRouter } from "../router.js";
+import { resolveMetadata, resolveRoute, searchParamsToRecord } from "../routing.js";
+import { listApiRoutes, listPages, matchApiRoute, scanApp, toApiManifest } from "../server/scan.js";
+import { runRouteHandlerWithCache } from "../server/cache-route.js";
+import { loadRuntimeManifest } from "../cli/run.js";
+import { installServerJsxRuntime } from "../server/bun-jsx.js";
+import { prepareServerManifest } from "../server/live-app.js";
+import { ServerComponentCache, ServerComponentsProvider } from "../server/server-components.js";
+import { loadTextConfig } from "../cli/config.js";
+import { clampRegion, frameContains, frameText, styledRows } from "./frame.js";
+import { FiberProbe, inspect } from "./inspect.js";
+import { parseKeyInput, textToKeyEvents } from "./keys.js";
+import { LogBuffer, txCodeOf } from "./logs.js";
+/** A tool-facing error with an optional `TX###` code. */
+export class SessionError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "SessionError";
+        this.code = code;
+    }
+}
+const nullConsole = { clear() { }, log() { } };
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const MIN_FRAME_GAP_MS = 8;
+/**
+ * React throttles revealing resolved Suspense boundaries (300ms after the
+ * last fallback commit), so a settled server-component promise may commit
+ * that much later: stay busy until it can have.
+ */
+const SUSPENSE_REVEAL_MS = 350;
+/** `setTimeout`-driven frames, with the pending set visible for idle detection. */
+class TrackedScheduler {
+    onActivity;
+    pending = new Set();
+    lastRun = 0;
+    constructor(onActivity) {
+        this.onActivity = onActivity;
+    }
+    request(cb) {
+        this.onActivity();
+        // A small gap caps runaway render loops at ~120fps without slowing input.
+        const delay = Math.max(0, this.lastRun + MIN_FRAME_GAP_MS - Date.now());
+        const h = setTimeout(() => {
+            this.pending.delete(h);
+            this.lastRun = Date.now();
+            cb();
+        }, delay);
+        this.pending.add(h);
+        return h;
+    }
+    cancel(handle) {
+        clearTimeout(handle);
+        this.pending.delete(handle);
+    }
+    dispose() {
+        for (const h of this.pending)
+            clearTimeout(h);
+        this.pending.clear();
+    }
+}
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+/** `@textjs/app` sources (`src/` or `dist/`): never purged on reload. */
+const PACKAGE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+export class HeadlessSession {
+    logs;
+    rootDir;
+    options;
+    scan;
+    manifest = null;
+    appRoot = null;
+    scheduler = null;
+    probe = null;
+    history;
+    theme;
+    cols = 100;
+    rows = 32;
+    resized = false;
+    generation = 0;
+    frameSeq = 0;
+    lastActivity = Date.now();
+    /** In-flight `fetch` calls per mount generation (a stale app's hung request never blocks idleness). */
+    inflight = new Map();
+    errorCursor = 0;
+    /** Normalized `options.origin` (no trailing slash). */
+    origin;
+    status = "failed";
+    loadError = null;
+    disposed = false;
+    /** Async Server Components' promises (pending ones keep the session busy). */
+    serverCache;
+    quietMs;
+    constructor(options) {
+        this.options = options;
+        this.rootDir = resolve(options.root);
+        this.logs = options.logs ?? new LogBuffer();
+        this.history = createMemoryHistory(options.path ?? "/");
+        this.quietMs = options.quietMs ?? 50;
+        this.origin = new URL(options.origin ?? "http://localhost:3000").origin;
+        this.serverCache = new ServerComponentCache({ onActivity: () => this.touch() });
+        this.history.listen(() => this.touch());
+    }
+    /** Load `text.config.ts`, import every route module and mount the app. */
+    static async start(options) {
+        const session = new HeadlessSession(options);
+        await initYoga();
+        await session.loadConfig();
+        await session.mount();
+        if (session.status === "failed") {
+            const err = session.loadError;
+            await session.dispose();
+            throw err instanceof Error ? err : new SessionError(errorMessage(err));
+        }
+        await session.settle();
+        session.errorCursor = session.logs.cursor;
+        return session;
+    }
+    touch() {
+        this.lastActivity = Date.now();
+    }
+    async loadConfig() {
+        let cfgCols;
+        let cfgRows;
+        let appDir = "app";
+        if (!this.options.skipConfig) {
+            const { config } = await loadTextConfig(this.rootDir, "serve");
+            const vp = config.viewport;
+            if (typeof vp?.width === "number")
+                cfgCols = vp.width;
+            if (typeof vp?.height === "number")
+                cfgRows = vp.height;
+            if (typeof vp?.theme === "string" && this.options.theme === undefined)
+                this.theme = vp.theme;
+            if (typeof config.appDir === "string")
+                appDir = config.appDir;
+        }
+        if (this.options.theme !== undefined)
+            this.theme = this.options.theme;
+        if (!this.resized) {
+            this.cols = clampCols(this.options.cols ?? cfgCols ?? 100);
+            this.rows = clampRows(this.options.rows ?? cfgRows ?? 32);
+        }
+        this.scan = scanApp(this.rootDir, appDir);
+        if (!existsSync(this.scan.appDir))
+            throw new SessionError(`No app/ directory found in ${this.rootDir}.`, "TX018");
+    }
+    trackFetch(gen, delta) {
+        const n = (this.inflight.get(gen) ?? 0) + delta;
+        if (n > 0)
+            this.inflight.set(gen, n);
+        else
+            this.inflight.delete(gen);
+        this.touch();
+    }
+    /**
+     * The app's `fetch`: same-origin URLs (`"/api/health"`,
+     * `"http://localhost:3000/api/x"`) run `app/**\/route.ts` handlers in-process
+     * exactly like `text dev`; everything else goes to the network.
+     */
+    async handleFetch(input, init) {
+        const gen = this.generation;
+        this.trackFetch(gen, 1);
+        try {
+            const raw = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+            const url = sameOriginUrl(raw, this.origin);
+            if (!url)
+                return await networkFetch()(input, init);
+            const hit = matchApiRoute(toApiManifest(this.scan), url.pathname);
+            if (!hit)
+                return new Response("Not Found", { status: 404 });
+            const mod = (await import(pathToFileURL(hit.file).href));
+            const request = input instanceof Request ? new Request(url, init ? new Request(input, init) : input) : new Request(url, init);
+            return await runRouteHandlerWithCache(mod, request, { params: hit.params, pattern: hit.pattern, pathname: url.pathname, cache: false });
+        }
+        finally {
+            this.trackFetch(gen, -1);
+        }
+    }
+    recordError(source, error, componentStack) {
+        if (isNavigationError(error))
+            return;
+        const args = [error];
+        if (componentStack)
+            args.push(`\nComponent stack:${componentStack}`);
+        this.logs.push("error", source, args);
+    }
+    async mount() {
+        attachFetch(this);
+        const gen = ++this.generation;
+        // `async function` components (e.g. `runtime = "server"` pages) render like in `text dev`.
+        installServerJsxRuntime(this.rootDir);
+        try {
+            this.manifest = await loadRuntimeManifest(this.scan);
+        }
+        catch (error) {
+            this.status = "failed";
+            this.loadError = error;
+            this.logs.push("error", "server", ["Failed to load app/ modules:", error]);
+            return;
+        }
+        const scheduler = new TrackedScheduler(() => this.touch());
+        this.scheduler = scheduler;
+        const root = createConsoleRootSync({
+            width: this.cols,
+            height: this.rows,
+            console: nullConsole,
+            input: new InputEngine({ document: null }),
+            registerGlobal: false,
+            scheduler,
+            minFrameInterval: 0,
+            theme: this.theme,
+            onFrame: (f) => {
+                if (f.skipped)
+                    return;
+                this.frameSeq++;
+                this.touch();
+            },
+            onUncaughtError: (error) => {
+                this.recordError("react", error);
+                if (gen === this.generation)
+                    this.status = "crashed";
+            },
+            onCaughtError: (error, info) => this.recordError("react", error, info.componentStack),
+            onRecoverableError: (error) => this.logs.push("warn", "react", [error]),
+        });
+        this.appRoot = root;
+        void root.waitUntilExit().then(() => {
+            if (gen === this.generation && !this.disposed && this.status === "running")
+                this.status = "exited";
+        });
+        this.status = "running";
+        this.loadError = null;
+        const probeRef = (p) => {
+            if (gen === this.generation)
+                this.probe = p;
+        };
+        const tree = (createElement(ServerComponentsProvider, { cache: this.serverCache }, createElement(FiberProbe, { ref: probeRef }, createElement(AppRouter, { routes: prepareServerManifest(this.manifest), history: this.history, theme: this.theme, documentTitle: false, errorStore: null }))));
+        fetchScope.run(this, () => {
+            root.render(tree);
+            root.flushSyncRender();
+        });
+    }
+    unmountApp() {
+        this.generation++;
+        this.scheduler?.dispose();
+        this.scheduler = null;
+        this.serverCache.clear();
+        const root = this.appRoot;
+        this.appRoot = null;
+        this.probe = null;
+        if (root && !root.unmounted) {
+            try {
+                root.unmount();
+            }
+            catch (error) {
+                this.logs.push("error", "server", ["Error while unmounting:", error]);
+            }
+        }
+    }
+    requireRoot() {
+        if (this.disposed)
+            throw new SessionError("The session is closed.");
+        const root = this.appRoot;
+        if (!root || this.status === "failed") {
+            throw new SessionError(`The app failed to load: ${errorMessage(this.loadError)}\nFix the error and call \`reload\`.`, txCodeOf(this.loadError));
+        }
+        if (root.unmounted || this.status === "exited")
+            throw new SessionError("The app exited (it called exit()). Call `reload` to start it again.");
+        return root;
+    }
+    /** Throw a tool error unless the app is mounted and running (not exited, crashed or failed to load). */
+    assertRunning() {
+        this.requireRoot();
+        if (this.status === "crashed")
+            throw new SessionError("The app crashed with an uncaught error (see `logs`). Fix it and call `reload`.");
+    }
+    /** Whether the app is idle right now (see the module comment). */
+    isIdle(quietMs = this.quietMs) {
+        if (!this.appRoot)
+            return true;
+        const pending = this.scheduler?.pending.size ?? 0;
+        const now = Date.now();
+        const server = this.serverCache.pending === 0 && now - this.serverCache.lastSettled >= SUSPENSE_REVEAL_MS;
+        return pending === 0 && (this.inflight.get(this.generation) ?? 0) === 0 && server && now - this.lastActivity >= quietMs;
+    }
+    /**
+     * Wait until the app is idle or `timeout` elapses. On timeout (a spinner or
+     * live chart that never stops), the pending frame is flushed so reads still
+     * see the latest committed tree.
+     */
+    async settle(options = {}) {
+        const quietMs = options.quietMs ?? this.quietMs;
+        const timeout = options.timeout ?? 1500;
+        const start = Date.now();
+        for (;;) {
+            throwIfAborted(options.signal);
+            if (this.isIdle(quietMs))
+                return { idle: true, waitedMs: Date.now() - start };
+            if (Date.now() - start >= timeout)
+                break;
+            await sleep(Math.min(10, Math.max(1, quietMs / 4)));
+        }
+        const root = this.appRoot;
+        if (root && !root.unmounted && (this.scheduler?.pending.size ?? 0) > 0)
+            root.flushSyncRender();
+        return { idle: false, waitedMs: Date.now() - start };
+    }
+    /**
+     * Send events in order, letting each one's effects and follow-up commits
+     * land before the next. Stops if the app exits or `signal` aborts (a timed
+     * out tool call must not keep typing into the next call's frame).
+     */
+    async dispatch(events, signal) {
+        const root = this.requireRoot();
+        for (const e of events) {
+            throwIfAborted(signal);
+            if (root.unmounted || root !== this.appRoot)
+                break;
+            this.touch();
+            fetchScope.run(this, () => {
+                try {
+                    if (e.kind === "key")
+                        root.input.emit("key", e.event);
+                    else if (e.kind === "wheel")
+                        root.input.emit("wheel", e.event);
+                    else
+                        root.input.handlePaste(e.text);
+                }
+                catch (error) {
+                    this.logs.push("error", "react", ["Error in input handler:", error]);
+                }
+            });
+            await sleep(0);
+        }
+    }
+    async press(keys, signal) {
+        const events = parseKeyInput(keys);
+        await this.dispatch(events.map((event) => ({ kind: "key", event })), signal);
+        return events.length;
+    }
+    async type(text, signal) {
+        const events = textToKeyEvents(text);
+        await this.dispatch(events.map((event) => ({ kind: "key", event })), signal);
+        return events.length;
+    }
+    async paste(text, signal) {
+        await this.dispatch([{ kind: "paste", text }], signal);
+    }
+    /**
+     * Mouse-wheel scroll by `rows` (positive scrolls down) and `cols`, sent in
+     * one-row steps like a wheel. Wheel input is not positional: it reaches the
+     * focused `<ScrollBox>` first, else every wheel-enabled one.
+     */
+    async scroll(rows, cols = 0, signal) {
+        const steps = Math.max(Math.abs(Math.trunc(rows)), Math.abs(Math.trunc(cols)), 1);
+        const event = (dy, dx) => ({ type: "wheel", deltaX: dx, deltaY: dy, rows: dy, cols: dx, ctrl: false, meta: false, shift: false, alt: false });
+        const events = Array.from({ length: steps }, (_, i) => {
+            const dy = i < Math.abs(Math.trunc(rows)) ? Math.sign(rows) : 0;
+            const dx = i < Math.abs(Math.trunc(cols)) ? Math.sign(cols) : 0;
+            return { kind: "wheel", event: event(dy, dx) };
+        }).filter((e) => e.event.rows !== 0 || e.event.cols !== 0);
+        await this.dispatch(events, signal);
+        return events.length;
+    }
+    resize(cols, rows) {
+        const root = this.requireRoot();
+        this.resized = true;
+        this.cols = clampCols(cols);
+        this.rows = clampRows(rows);
+        this.touch();
+        root.renderer.resize(this.cols, this.rows);
+        return { cols: this.cols, rows: this.rows };
+    }
+    navigate(target) {
+        this.requireRoot();
+        this.touch();
+        if (target === "back")
+            this.history.back();
+        else if (target === "forward")
+            this.history.forward();
+        else if (target.replace)
+            this.history.replace(target.path);
+        else
+            this.history.push(target.path);
+    }
+    get href() {
+        return this.history.location.href;
+    }
+    routes() {
+        return {
+            pages: listPages(this.scan),
+            api: listApiRoutes(this.scan).map((r) => ({ pattern: r.pattern, file: toProjectPath(this.rootDir, r.file) })),
+            current: this.href,
+        };
+    }
+    /** Read the current frame. Errors logged since the previous read are counted in `newErrors`. */
+    frame(options = {}) {
+        const root = this.appRoot;
+        const loc = this.history.location;
+        let route = loc.pathname;
+        let title;
+        if (this.manifest) {
+            const match = resolveRoute(this.manifest, loc.pathname);
+            route = match.pattern;
+            title = resolveMetadata(match, searchParamsToRecord(loc.search)).title;
+        }
+        const newErrors = this.logs.errorsSince(this.errorCursor);
+        if (!options.peek)
+            this.errorCursor = this.logs.cursor;
+        const base = { href: loc.href, route, ...(title !== undefined ? { title } : {}), frame: this.frameSeq, newErrors, status: this.status };
+        if (!root)
+            return { ...base, text: "", cols: this.cols, rows: this.rows, idle: true, focus: null, cursor: null };
+        const buffer = root.renderer.buffer;
+        const focus = this.focusSummary();
+        return {
+            ...base,
+            text: frameText(buffer, options.region, options.trim),
+            ...(options.region ? { region: clampRegion(buffer, options.region) } : {}),
+            cols: buffer.width,
+            rows: buffer.height,
+            idle: this.isIdle(),
+            focus,
+            cursor: focus?.bounds ? findCursor(root, focus.bounds) : null,
+            ...(options.styles ? { styles: styledRows(buffer, options.region) } : {}),
+        };
+    }
+    contains(text) {
+        const root = this.appRoot;
+        return root ? frameContains(root.renderer.buffer, text) : false;
+    }
+    get buffer() {
+        return this.appRoot?.renderer.buffer ?? null;
+    }
+    get fiberProbe() {
+        return this.probe;
+    }
+    /** The mounted scene and grid size, for paint-order hit testing. */
+    get sceneGrid() {
+        const root = this.appRoot;
+        if (!root || root.unmounted)
+            return null;
+        return { root: root.rootNode, cols: root.renderer.buffer.width, rows: root.renderer.buffer.height };
+    }
+    inspect(options = {}) {
+        const root = this.requireRoot();
+        return inspect(this.probe, root.focus, options);
+    }
+    focusSummary() {
+        const root = this.appRoot;
+        if (!root)
+            return null;
+        const id = root.focus.getActiveId();
+        if (id === null)
+            return null;
+        const info = inspect(this.probe, root.focus, { hosts: false }).focusables.find((f) => f.id === id);
+        return { id, ...(info?.component ? { component: info.component } : {}), ...(info?.bounds ? { bounds: info.bounds } : {}) };
+    }
+    /**
+     * Call an `app/**\/route.ts` handler in-process. The body is read up to
+     * `maxBytes` (then cancelled); event streams are read for `streamMs` and
+     * cancelled, so an SSE route returns its first events instead of hanging.
+     */
+    async request(path, init = {}, signal) {
+        const url = path.startsWith("/") ? sameOriginUrl(path, this.origin) : null;
+        if (!url)
+            throw new SessionError(`fetch only calls the app's own route handlers; pass a path like "/api/health" (got ${JSON.stringify(path)}).`);
+        attachFetch(this);
+        const hit = matchApiRoute(toApiManifest(this.scan), url.pathname);
+        const method = (init.method ?? "GET").toUpperCase();
+        const response = await abortable(fetchScope.run(this, () => this.handleFetch(url.href, { method, headers: init.headers, body: method === "GET" || method === "HEAD" ? undefined : init.body, signal })), signal);
+        const maxBytes = init.maxBytes ?? 64 * 1024;
+        const headers = {};
+        response.headers.forEach((v, k) => {
+            headers[k] = v;
+        });
+        const type = response.headers.get("content-type") ?? "";
+        const stream = /event-stream/i.test(type);
+        const read = await readBody(response, maxBytes, stream ? (init.streamMs ?? 1000) : Number.POSITIVE_INFINITY, signal);
+        const textual = type === "" || /^text\/|json|xml|javascript|ndjson|x-www-form-urlencoded|event-stream/i.test(type);
+        const body = textual ? new TextDecoder().decode(read.bytes) : `<${read.bytes.length}${read.truncated ? "+" : ""} bytes of ${type}>`;
+        return {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            body,
+            truncated: read.truncated,
+            ...(stream && read.open ? { streaming: true } : {}),
+            route: hit ? hit.pattern : null,
+        };
+    }
+    /**
+     * Re-import the app after file changes: unmount, purge every module under
+     * the project root from the module cache, re-scan `app/`, re-import and
+     * remount at the current location (history is kept).
+     */
+    async reload() {
+        if (this.disposed)
+            throw new SessionError("The session is closed.");
+        this.unmountApp();
+        const purged = purgeModuleCache(this.rootDir);
+        try {
+            await this.loadConfig();
+        }
+        catch (error) {
+            this.status = "failed";
+            this.loadError = error;
+            this.logs.push("error", "server", ["Failed to load the app:", error]);
+            throw new SessionError(`Reload failed: ${errorMessage(error)}\nFix the error and call \`reload\`.`, txCodeOf(error));
+        }
+        await this.mount();
+        if (this.status === "failed") {
+            throw new SessionError(`Reload failed: ${errorMessage(this.loadError)}`, txCodeOf(this.loadError));
+        }
+        this.touch();
+        return { purged };
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.unmountApp();
+        detachFetch(this);
+        this.history.dispose?.();
+    }
+}
+function clampCols(n) {
+    return Math.max(10, Math.min(1000, Math.floor(Number.isFinite(n) ? n : 100)));
+}
+function clampRows(n) {
+    return Math.max(3, Math.min(500, Math.floor(Number.isFinite(n) ? n : 32)));
+}
+function toProjectPath(root, file) {
+    return relative(root, file).split(sep).join("/");
+}
+/** A single inverse-video cell inside the focused component is the block cursor of an `<Input>` / `<Textarea>`. */
+function findCursor(root, b) {
+    const buf = root.renderer.buffer;
+    let hit = null;
+    for (let y = b.y; y < b.y + b.height; y++) {
+        for (let x = b.x; x < b.x + b.width; x++) {
+            const c = buf.getCell(x, y);
+            // The second cell of a wide grapheme under the cursor is the same cursor.
+            if (!c || (c.attrs & ATTR_INVERSE) === 0 || (c.attrs & ATTR_WIDE_CONT) !== 0)
+                continue;
+            if (hit)
+                return null;
+            hit = { x, y };
+        }
+    }
+    return hit;
+}
+function realpath(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+/**
+ * Delete every cached module under `root` (except dependencies and Text.js
+ * itself) so the next `import()` re-evaluates it. Bun's `require.cache`
+ * covers ES modules too.
+ */
+export function purgeModuleCache(root) {
+    const cache = (typeof require !== "undefined" ? require.cache : undefined);
+    if (!cache)
+        return 0;
+    const roots = [resolve(root), realpath(resolve(root))].map((r) => (r.endsWith(sep) ? r : r + sep));
+    const pkg = [PACKAGE_DIR, realpath(PACKAGE_DIR)].map((r) => r + sep);
+    let n = 0;
+    for (const key of Object.keys(cache)) {
+        const file = key.startsWith("file://") ? fileURLToPath(key) : key;
+        if (!roots.some((r) => file.startsWith(r)))
+            continue;
+        if (file.includes(`${sep}node_modules${sep}`) || pkg.some((p) => file.startsWith(p)))
+            continue;
+        delete cache[key];
+        n++;
+    }
+    return n;
+}
+/** Which session an app `fetch()` belongs to, when async context propagates (input dispatch, renders, `request`). */
+const fetchScope = new AsyncLocalStorage();
+/** Sessions routing `globalThis.fetch`, oldest first (the newest handles calls without a scope). */
+const fetchSessions = [];
+let nativeFetch = null;
+let routedFetch = null;
+/** The `fetch` that existed before any session installed its router. */
+function networkFetch() {
+    return nativeFetch ?? globalThis.fetch;
+}
+/**
+ * Route `globalThis.fetch` through the session registry. One router serves
+ * every in-process session, and the original `fetch` comes back only when
+ * the last session detaches, whatever the dispose order.
+ */
+function attachFetch(session) {
+    const g = globalThis;
+    if (!routedFetch || g.fetch !== routedFetch) {
+        nativeFetch = g.fetch;
+        const router = (input, init) => {
+            const owner = fetchScope.getStore() ?? fetchSessions[fetchSessions.length - 1];
+            return owner ? owner.handleFetch(input, init) : nativeFetch(input, init);
+        };
+        routedFetch = Object.assign(router, { preconnect: () => undefined });
+        g.fetch = routedFetch;
+    }
+    if (!fetchSessions.includes(session))
+        fetchSessions.push(session);
+}
+function detachFetch(session) {
+    const i = fetchSessions.indexOf(session);
+    if (i >= 0)
+        fetchSessions.splice(i, 1);
+    if (fetchSessions.length > 0)
+        return;
+    const g = globalThis;
+    if (routedFetch && g.fetch === routedFetch && nativeFetch)
+        g.fetch = nativeFetch;
+    routedFetch = null;
+    nativeFetch = null;
+}
+/**
+ * `raw` as a URL on `origin`, or `null` when it targets anything else.
+ * Paths like `//evil.com` and `/\evil.com` (a backslash is a slash in
+ * special-scheme URLs) are protocol-relative, not same-origin.
+ */
+export function sameOriginUrl(raw, origin) {
+    if (raw.startsWith("/") && /^\/[\\/]/.test(raw))
+        return null;
+    let url;
+    try {
+        url = new URL(raw, origin);
+    }
+    catch {
+        return null;
+    }
+    return url.origin === origin ? url : null;
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error ? signal.reason : new SessionError("The operation was cancelled.");
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortReason(signal);
+}
+/** `promise`, rejecting as soon as `signal` aborts. */
+function abortable(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abortReason(signal));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortReason(signal));
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((v) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(v);
+        }, (e) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(e);
+        });
+    });
+}
+/**
+ * Read at most `maxBytes` of a response body, for at most `windowMs`, then
+ * cancel it. `open` is set when the body was still streaming.
+ */
+export async function readBody(response, maxBytes, windowMs, signal) {
+    const body = response.body;
+    if (!body)
+        return { bytes: new Uint8Array(0), truncated: false, open: false };
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    let open = true;
+    const deadline = Date.now() + windowMs;
+    const TIMEOUT = Symbol("timeout");
+    try {
+        while (total <= maxBytes) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                truncated = true;
+                break;
+            }
+            let timer;
+            const tick = Number.isFinite(remaining) ? new Promise((r) => (timer = setTimeout(() => r(TIMEOUT), remaining))) : null;
+            const next = await abortable(tick ? Promise.race([reader.read(), tick]) : reader.read(), signal).finally(() => clearTimeout(timer));
+            if (next === TIMEOUT) {
+                truncated = true;
+                break;
+            }
+            if (next.done) {
+                open = false;
+                break;
+            }
+            chunks.push(next.value);
+            total += next.value.length;
+        }
+        if (total > maxBytes)
+            truncated = true;
+    }
+    finally {
+        if (open)
+            await reader.cancel().catch(() => undefined);
+    }
+    const all = new Uint8Array(Math.min(total, maxBytes));
+    let offset = 0;
+    for (const c of chunks) {
+        if (offset >= all.length)
+            break;
+        const part = c.subarray(0, all.length - offset);
+        all.set(part, offset);
+        offset += part.length;
+    }
+    return { bytes: all, truncated, open: open && truncated };
+}
+//# sourceMappingURL=session.js.map