@nifrajs/web 3.5.0 → 4.0.2

package/dist/dev-feed.js

@@ -0,0 +1,797 @@
+/**
+ * `@nifrajs/web/dev-feed` - what a running dev server saw, kept so the agent driving it can ask.
+ *
+ * Both dev servers (`./dev.ts`, `./vite.ts`) record into one {@link DevFeed}: every error with its
+ * structured {@link Diagnostic} (failures a `_error` boundary rendered, backend 500s, build and guard
+ * failures, browser errors, crashes), every console line, and every request. `nifra errors`,
+ * `nifra logs` and `nifra inspect` (and their MCP tools) read it back over the dev server's own HTTP
+ * surface, found through the discovery record this module also owns.
+ *
+ * Three properties hold for everything stored here:
+ * - Redacted on the way in. Secret formats and non-public env values are scrubbed before an entry
+ *   exists, so nothing unredacted is ever served, persisted, or handed to an agent.
+ * - Correlated. An entry recorded while a request is in flight carries that request's id.
+ * - Edit-aware. Every entry has a monotonic `seq` (query with `since`) and the `generation` it was last
+ *   seen in; a file change bumps the generation, so an error recorded before the latest edit reads as
+ *   `stale` instead of current.
+ *
+ * Dev-only by construction: no production entry imports this module.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { formatWithOptions, stripVTControlCharacters } from "node:util";
+import { buildDiagnostic, } from "./diagnostic.js";
+import { createRedactor } from "./internal/secret-scan.js";
+import { originalPosition, ssrSourceMaps } from "./internal/source-map.js";
+/** Version of the HTTP + record contract between a dev server and the tools that read it. */
+export const DEV_FEED_SCHEMA = 1;
+/** The dev server's agent-facing endpoints. All live under `/__nifra/`, which no route can produce. */
+export const DEV_FEED_PATHS = Object.freeze({
+    identity: "/__nifra/dev",
+    errors: "/__nifra/errors",
+    logs: "/__nifra/logs",
+    requests: "/__nifra/requests",
+    clientEvent: "/__nifra/client-event",
+    indicator: "/__nifra/dev-indicator.js",
+});
+/** Request header carrying the agent token from the discovery record. */
+export const DEV_TOKEN_HEADER = "x-nifra-dev-token";
+/** Response header naming the request id every entry recorded during that request carries. */
+export const DEV_REQUEST_ID_HEADER = "x-nifra-request-id";
+/** Response header marking a body as dev-feed JSON (so a tool can tell it from an app route). */
+export const DEV_FEED_HEADER = "x-nifra-dev-feed";
+/** Discovery record and persisted log, relative to the project root. `.nifra/` is gitignored. */
+export const DEV_SERVER_RECORD_FILE = ".nifra/dev-server.json";
+export const DEV_SERVER_LOG_FILE = ".nifra/dev-server.log";
+/**
+ * Every file the feed writes (record, its temp file, log, rotated log): what a file watcher skips. A
+ * RegExp, not a glob: a glob's `**` does not cross a dot-directory such as the project's own path.
+ */
+export const DEV_SERVER_FILES = /[\\/]\.nifra[\\/]dev-server\./;
+export const DEV_ERROR_CATEGORIES = [
+    "ssr",
+    "page",
+    "api",
+    "build",
+    "browser",
+    "hydration",
+    "process",
+];
+export const DEV_LOG_LEVELS = ["debug", "info", "log", "warn", "error"];
+/** Narrow a string to a {@link DevLogLevel}. */
+export function isDevLogLevel(value) {
+    return DEV_LOG_LEVELS.some((level) => level === value);
+}
+/** Narrow a string to a {@link DevErrorCategory}. */
+export function isDevErrorCategory(value) {
+    return DEV_ERROR_CATEGORIES.some((category) => category === value);
+}
+export const DEFAULT_DEV_FEED_LIMITS = Object.freeze({
+    errors: 100,
+    logs: 2000,
+    logBytes: 1024 * 1024,
+    requests: 500,
+    message: 8 * 1024,
+    stack: 16 * 1024,
+});
+// One store per process: a second copy of this module (a dual install) must still see the request the
+// first one started, or its log lines would land untagged.
+const ALS_KEY = Symbol.for("nifra.devFeed.requestContext");
+const requestContext = sharedRequestContext();
+function sharedRequestContext() {
+    const existing = Reflect.get(globalThis, ALS_KEY);
+    if (existing instanceof AsyncLocalStorage)
+        return existing;
+    const created = new AsyncLocalStorage();
+    Reflect.set(globalThis, ALS_KEY, created);
+    return created;
+}
+/** Run `fn` as the handling of one request: entries recorded inside it carry `ctx.requestId`. */
+export function runWithDevRequest(ctx, fn) {
+    return requestContext.run(ctx, fn);
+}
+/** The request being handled on this async path, if any. */
+export function currentDevRequest() {
+    return requestContext.getStore();
+}
+/** The request in flight on this async path, when it belongs to the feed `feedId`. */
+function currentRequestFor(feedId) {
+    const ctx = requestContext.getStore();
+    return ctx?.feedId === feedId ? ctx : undefined;
+}
+const nowIso = () => new Date().toISOString();
+const clampLimit = (value, fallback, max) => value === undefined || !Number.isFinite(value) || value < 1
+    ? fallback
+    : Math.min(Math.floor(value), max);
+/** FNV-1a: a stable short id for a failure fingerprint. Not a security boundary. */
+function fnv1a(text) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        hash ^= text.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+const cap = (text, max) => text.length <= max ? text : `${text.slice(0, max)}... [${text.length - max} more chars]`;
+const firstLine = (text) => {
+    const end = text.indexOf("\n");
+    return end === -1 ? text : text.slice(0, end);
+};
+function snapshotError(record, currentGeneration) {
+    const entry = {
+        seq: record.seq,
+        id: record.id,
+        category: record.category,
+        source: record.source,
+        diagnostic: record.diagnostic,
+        count: record.count,
+        firstAt: record.firstAt,
+        lastAt: record.lastAt,
+        generation: record.generation,
+        stale: record.generation < currentGeneration,
+    };
+    if (record.requestId !== undefined)
+        entry.requestId = record.requestId;
+    if (record.route !== undefined)
+        entry.route = record.route;
+    if (record.page !== undefined)
+        entry.page = record.page;
+    if (record.resolvedAt !== undefined)
+        entry.resolvedAt = record.resolvedAt;
+    return entry;
+}
+function snapshotTrace(trace) {
+    const entry = {
+        seq: trace.seq,
+        requestId: trace.requestId,
+        method: trace.method,
+        path: trace.path,
+        at: trace.at,
+        errorIds: [...trace.errorIds],
+        logCount: trace.logCount,
+    };
+    if (trace.status !== undefined)
+        entry.status = trace.status;
+    if (trace.durationMs !== undefined)
+        entry.durationMs = trace.durationMs;
+    if (trace.bytes !== undefined)
+        entry.bytes = trace.bytes;
+    if (trace.isr !== undefined)
+        entry.isr = trace.isr;
+    return entry;
+}
+function evictOldest(map, max) {
+    while (map.size > max) {
+        const oldest = map.keys().next();
+        if (oldest.done === true)
+            return;
+        map.delete(oldest.value);
+    }
+}
+let feedCounter = 0;
+/** Create the store a dev server records into. */
+export function createDevFeed(options) {
+    const limits = { ...DEFAULT_DEV_FEED_LIMITS, ...options.limits };
+    const root = options.root;
+    const redactText = createRedactor(options.env ?? process.env, options.publicEnvPrefix);
+    const persist = options.persist === false ? undefined : createPersistence(root);
+    feedCounter += 1;
+    const id = `feed${feedCounter}-${randomBytes(3).toString("hex")}`;
+    const errors = new Map();
+    const traces = new Map();
+    let logs = [];
+    let logBytes = 0;
+    let dropped = 0;
+    let seq = 0;
+    let generation = 0;
+    const redactFrame = (frame) => ({
+        ...frame,
+        raw: cap(redactText(frame.raw), 1024),
+    });
+    const redactDiagnostic = (diagnostic) => {
+        const redacted = {
+            ...diagnostic,
+            message: cap(redactText(diagnostic.message), limits.message),
+            frames: diagnostic.frames.slice(0, 50).map(redactFrame),
+        };
+        if (diagnostic.request !== undefined) {
+            redacted.request = {
+                method: diagnostic.request.method,
+                url: cap(redactText(diagnostic.request.url), 2048),
+            };
+        }
+        if (diagnostic.codeframe !== undefined) {
+            redacted.codeframe = {
+                ...diagnostic.codeframe,
+                lines: diagnostic.codeframe.lines.map((line) => ({
+                    ...line,
+                    text: cap(redactText(line.text), 400),
+                })),
+            };
+        }
+        return redacted;
+    };
+    const recordDiagnostic = (raw, meta) => {
+        const diagnostic = redactDiagnostic(raw);
+        const requestId = meta.requestId ?? currentRequestFor(id)?.requestId;
+        const top = diagnostic.frames.find((frame) => frame.file !== undefined);
+        const fingerprint = [
+            meta.category,
+            diagnostic.code,
+            diagnostic.name,
+            firstLine(diagnostic.message).slice(0, 300),
+            top === undefined ? "" : `${top.file}:${top.line}`,
+        ].join("|");
+        const key = `e_${fnv1a(fingerprint)}`;
+        const at = nowIso();
+        seq += 1;
+        const existing = errors.get(key);
+        const record = existing ?? {
+            seq,
+            id: key,
+            category: meta.category,
+            source: meta.source ?? "server",
+            diagnostic,
+            count: 0,
+            firstAt: at,
+            lastAt: at,
+            generation,
+            requestId: undefined,
+            route: undefined,
+            page: undefined,
+            resolvedAt: undefined,
+        };
+        record.seq = seq;
+        record.diagnostic = diagnostic;
+        record.count += 1;
+        record.lastAt = at;
+        record.generation = generation;
+        record.resolvedAt = undefined;
+        if (requestId !== undefined)
+            record.requestId = requestId;
+        if (meta.route !== undefined)
+            record.route = meta.route;
+        if (meta.page !== undefined)
+            record.page = meta.page;
+        // Re-insert: Map order is recency order, which eviction relies on.
+        errors.delete(key);
+        errors.set(key, record);
+        evictOldest(errors, limits.errors);
+        if (requestId !== undefined) {
+            const trace = traces.get(requestId);
+            if (trace !== undefined && !trace.errorIds.includes(key))
+                trace.errorIds.push(key);
+        }
+        const entry = snapshotError(record, generation);
+        persist?.write({ t: "error", ...entry }, true);
+        return entry;
+    };
+    const recordLog = (level, message, meta = {}) => {
+        const text = cap(redactText(message), limits.message);
+        if (text.length === 0)
+            return;
+        const requestId = meta.requestId ?? currentRequestFor(id)?.requestId;
+        seq += 1;
+        const entry = {
+            seq,
+            at: nowIso(),
+            level,
+            source: meta.source ?? "server",
+            message: text,
+        };
+        if (requestId !== undefined)
+            entry.requestId = requestId;
+        if (meta.page !== undefined)
+            entry.page = meta.page;
+        logs.push(entry);
+        logBytes += text.length;
+        if (logs.length > limits.logs || logBytes > limits.logBytes) {
+            // Past the count cap, evict an extra tenth so a full ring does not re-slice on every line.
+            const byCount = logs.length > limits.logs
+                ? Math.min(logs.length - 1, logs.length - limits.logs + Math.floor(limits.logs / 10))
+                : 0;
+            let cut = 0;
+            let freed = 0;
+            while (cut < logs.length - 1 && (cut < byCount || logBytes - freed > limits.logBytes)) {
+                freed += logs[cut]?.message.length ?? 0;
+                cut += 1;
+            }
+            logs = logs.slice(cut);
+            logBytes -= freed;
+            dropped += cut;
+        }
+        if (requestId !== undefined) {
+            const trace = traces.get(requestId);
+            if (trace !== undefined)
+                trace.logCount += 1;
+        }
+        persist?.write({ t: "log", ...entry }, level === "error");
+    };
+    return {
+        id,
+        root,
+        get generation() {
+            return generation;
+        },
+        get cursor() {
+            return seq;
+        },
+        recordError(error, meta) {
+            const diagnosticOptions = { root };
+            if (meta.request !== undefined)
+                diagnosticOptions.request = meta.request;
+            if (options.showSource !== undefined)
+                diagnosticOptions.showSource = options.showSource;
+            if (meta.source !== "browser")
+                diagnosticOptions.remap = ssrRemap;
+            return recordDiagnostic(buildDiagnostic(error, diagnosticOptions), meta);
+        },
+        recordDiagnostic,
+        recordLog,
+        startRequest(requestId, method, path) {
+            seq += 1;
+            traces.set(requestId, {
+                seq,
+                requestId,
+                method,
+                path: cap(redactText(path), 2048),
+                at: nowIso(),
+                status: undefined,
+                durationMs: undefined,
+                bytes: undefined,
+                isr: undefined,
+                errorIds: [],
+                logCount: 0,
+            });
+            evictOldest(traces, limits.requests);
+        },
+        finishRequest(requestId, response, durationMs) {
+            const trace = traces.get(requestId);
+            if (trace === undefined)
+                return;
+            trace.status = response.status;
+            trace.durationMs = Math.round(durationMs * 100) / 100;
+            trace.bytes = response.bytes;
+            trace.isr = response.isr;
+        },
+        markChange() {
+            generation += 1;
+        },
+        resolve(category) {
+            const at = nowIso();
+            for (const record of errors.values()) {
+                if (record.category === category && record.resolvedAt === undefined)
+                    record.resolvedAt = at;
+            }
+        },
+        errors(query = {}) {
+            const since = query.since ?? 0;
+            const selected = [];
+            for (const record of errors.values()) {
+                if (record.seq <= since)
+                    continue;
+                if (query.categories !== undefined && !query.categories.includes(record.category))
+                    continue;
+                if (query.includeResolved !== true && record.resolvedAt !== undefined)
+                    continue;
+                if (query.includeStale === false && record.generation < generation)
+                    continue;
+                if (query.requestId !== undefined && record.requestId !== query.requestId)
+                    continue;
+                selected.push(snapshotError(record, generation));
+            }
+            const limit = clampLimit(query.limit, 50, limits.errors);
+            return { errors: selected.slice(-limit), cursor: seq, generation };
+        },
+        logs(query = {}) {
+            const since = query.since ?? 0;
+            const needle = query.grep?.toLowerCase();
+            const selected = logs.filter((entry) => entry.seq > since &&
+                (query.levels === undefined || query.levels.includes(entry.level)) &&
+                (query.source === undefined || entry.source === query.source) &&
+                (query.requestId === undefined || entry.requestId === query.requestId) &&
+                (needle === undefined || entry.message.toLowerCase().includes(needle)));
+            const limit = clampLimit(query.limit, 200, limits.logs);
+            return { logs: selected.slice(-limit), cursor: seq, generation, dropped };
+        },
+        requests(query = {}) {
+            const since = query.since ?? 0;
+            const selected = [];
+            for (const trace of traces.values()) {
+                if (trace.seq <= since)
+                    continue;
+                if (query.path !== undefined && !trace.path.startsWith(query.path))
+                    continue;
+                if (query.requestId !== undefined && trace.requestId !== query.requestId)
+                    continue;
+                selected.push(snapshotTrace(trace));
+            }
+            const limit = clampLimit(query.limit, 50, limits.requests);
+            return { requests: selected.slice(-limit), cursor: seq, generation };
+        },
+        counts: () => ({ errors: errors.size, logs: logs.length, requests: traces.size }),
+        redact: redactText,
+        flush: () => persist?.flush(),
+        close: () => persist?.close(),
+    };
+}
+// ---------------------------------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------------------------------
+const LOG_ROTATE_BYTES = 2 * 1024 * 1024;
+const LOG_FLUSH_MS = 250;
+/**
+ * NDJSON on disk so a crashed dev server still leaves a record. Error-level writes are synchronous (the
+ * line most worth keeping is the one written just before a crash); the rest is buffered briefly. One
+ * rotation (`.1`) bounds the footprint. A write failure disables persistence rather than breaking dev.
+ */
+function createPersistence(root) {
+    const path = join(root, DEV_SERVER_LOG_FILE);
+    let buffer = [];
+    let size = 0;
+    let timer;
+    let disabled = false;
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        size = existsSync(path) ? statSync(path).size : 0;
+    }
+    catch {
+        disabled = true;
+    }
+    const flush = () => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        if (disabled || buffer.length === 0)
+            return;
+        const chunk = buffer.join("");
+        buffer = [];
+        try {
+            if (size + chunk.length > LOG_ROTATE_BYTES) {
+                renameSync(path, `${path}.1`);
+                size = 0;
+            }
+            appendFileSync(path, chunk);
+            size += chunk.length;
+        }
+        catch {
+            disabled = true;
+        }
+    };
+    return {
+        write(entry, sync) {
+            if (disabled)
+                return;
+            buffer.push(`${JSON.stringify(entry)}\n`);
+            if (sync)
+                flush();
+            else if (timer === undefined) {
+                timer = setTimeout(flush, LOG_FLUSH_MS);
+                timer.unref?.();
+            }
+        },
+        flush,
+        close: () => {
+            flush();
+            disabled = true;
+        },
+    };
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isPersistedError(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.seq === "number" &&
+        isDevErrorCategory(value.category) &&
+        isRecord(value.diagnostic));
+}
+function isPersistedLog(value) {
+    return (isRecord(value) &&
+        typeof value.message === "string" &&
+        typeof value.seq === "number" &&
+        isDevLogLevel(value.level));
+}
+/** The persisted record of a dev server that may no longer be running: newest last. */
+export function readPersistedFeed(root, limit = 200) {
+    const path = join(root, DEV_SERVER_LOG_FILE);
+    const errors = new Map();
+    const logs = [];
+    for (const file of [`${path}.1`, path]) {
+        let text;
+        try {
+            text = readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split("\n")) {
+            if (line.length === 0)
+                continue;
+            let value;
+            try {
+                value = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(value))
+                continue;
+            const { t, ...entry } = value;
+            if (t === "error" && isPersistedError(entry)) {
+                errors.delete(entry.id);
+                errors.set(entry.id, entry);
+            }
+            else if (t === "log" && isPersistedLog(entry)) {
+                logs.push(entry);
+            }
+        }
+    }
+    return { errors: [...errors.values()].slice(-limit), logs: logs.slice(-limit) };
+}
+/**
+ * Record a dev server process that died, from the process that supervised it (`nifra dev` re-execs the
+ * Bun pipeline and pipes the child's stderr). The child's own monitor never sees an unhandled rejection
+ * on Bun, and a native crash print bypasses the console, so the supervisor's view of stderr is the
+ * record that survives. Persisted only: there is no live server left to serve it.
+ */
+export function recordDevCrash(root, exitCode, stderrTail) {
+    const feed = createDevFeed({ root });
+    const summary = `the dev server exited with code ${exitCode ?? "unknown"}`;
+    const error = new Error(summary);
+    error.name = "DevServerExit";
+    error.stack = `DevServerExit: ${summary}\n${stderrTail.slice(-DEFAULT_DEV_FEED_LIMITS.stack)}`;
+    feed.recordError(error, { category: "process" });
+    feed.close();
+}
+/** A fresh 256-bit token. */
+export function createDevToken() {
+    return randomBytes(32).toString("base64url");
+}
+/** Write the record atomically (temp file + rename) and owner-only. */
+export function writeDevServerRecord(root, record) {
+    const path = join(root, DEV_SERVER_RECORD_FILE);
+    mkdirSync(dirname(path), { recursive: true });
+    const temp = `${path}.${process.pid}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temp, path);
+}
+/** Remove the record only while it is still this server's: a newer server may have replaced it. */
+export function removeDevServerRecord(root, token) {
+    // @nifra-gate-reviewed: the server comparing its own token with a file on this machine; no request
+    // reaches this comparison.
+    if (readDevServerRecord(root)?.token !== token)
+        return;
+    rmSync(join(root, DEV_SERVER_RECORD_FILE), { force: true });
+}
+const isPort = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value < 65536;
+function isDevServerRecord(value) {
+    return (isRecord(value) &&
+        typeof value.schema === "number" &&
+        typeof value.pid === "number" &&
+        Number.isSafeInteger(value.pid) &&
+        isPort(value.port) &&
+        typeof value.url === "string" &&
+        (value.pipeline === "bun" || value.pipeline === "vite") &&
+        typeof value.root === "string" &&
+        typeof value.startedAt === "string" &&
+        typeof value.token === "string" &&
+        value.token.length >= 32);
+}
+/** The record at `root`, or undefined when absent or malformed. Says nothing about liveness. */
+export function readDevServerRecord(root) {
+    let value;
+    try {
+        value = JSON.parse(readFileSync(join(root, DEV_SERVER_RECORD_FILE), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    return isDevServerRecord(value) ? value : undefined;
+}
+/** Whether a process with `pid` exists (EPERM means it exists but is not ours). */
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error instanceof Error && "code" in error && error.code === "EPERM";
+    }
+}
+const CONSOLE_METHODS = ["debug", "info", "log", "warn", "error", "trace"];
+const CONSOLE_LEVELS = {
+    debug: "debug",
+    info: "info",
+    log: "log",
+    warn: "warn",
+    error: "error",
+    trace: "log",
+};
+// Structural, not `instanceof`: a second copy of this module must join the first one's patch rather
+// than layer another on top and capture every line twice.
+const isCaptureState = (value) => isRecord(value) &&
+    value.sinks instanceof Set &&
+    typeof value.depth === "number" &&
+    typeof value.restore === "function";
+const CAPTURE_KEY = Symbol.for("nifra.devFeed.capture");
+const MAX_PARTIAL_LINE = 16 * 1024;
+/** Format console arguments the way the console itself would, without color. */
+export function formatConsoleArgs(args) {
+    try {
+        return formatWithOptions({ colors: false, depth: 4, breakLength: Number.POSITIVE_INFINITY, maxArrayLength: 50 }, ...args);
+    }
+    catch {
+        return args.map((arg) => String(arg)).join(" ");
+    }
+}
+const isCoreLogEntry = (value) => isRecord(value) && typeof value.level === "string" && typeof value.message === "string";
+/** Parse a line core's default JSON logger wrote, or undefined for anything else. */
+export function parseCoreLogLine(line) {
+    if (!line.startsWith("{") || !line.endsWith("}"))
+        return undefined;
+    try {
+        const value = JSON.parse(line);
+        return isCoreLogEntry(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The thrown error core's `unhandled request error` log line describes, rebuilt for a Diagnostic. */
+export function errorFromCoreLog(entry) {
+    if (entry.message !== "unhandled request error")
+        return undefined;
+    const name = typeof entry.name === "string" ? entry.name : "Error";
+    const detail = typeof entry.detail === "string" ? entry.detail : name;
+    const error = new Error(detail);
+    error.name = name;
+    error.stack = typeof entry.stack === "string" ? entry.stack : `${name}: ${detail}`;
+    return error;
+}
+/**
+ * Tee the process's console and stdout/stderr into `sink`, leaving the real output untouched. Global
+ * and reference-counted: several dev servers (tests start many) share one patch, and the originals come
+ * back when the last sink detaches. Returns the detach function.
+ */
+export function installCapture(sink) {
+    const existing = Reflect.get(globalThis, CAPTURE_KEY);
+    const state = isCaptureState(existing) ? existing : patchProcess();
+    Reflect.set(globalThis, CAPTURE_KEY, state);
+    state.sinks.add(sink);
+    let attached = true;
+    return () => {
+        if (!attached)
+            return;
+        attached = false;
+        state.sinks.delete(sink);
+        if (state.sinks.size === 0 && Reflect.get(globalThis, CAPTURE_KEY) === state) {
+            state.restore();
+            Reflect.deleteProperty(globalThis, CAPTURE_KEY);
+        }
+    };
+}
+function patchProcess() {
+    const state = { sinks: new Set(), depth: 0, restore: () => { } };
+    const dispatch = (level, message, structured) => {
+        const request = requestContext.getStore();
+        for (const sink of state.sinks) {
+            if (request !== undefined && request.feedId !== sink.feedId)
+                continue;
+            try {
+                if (structured !== undefined && sink.structured !== undefined) {
+                    sink.structured(structured, request);
+                }
+                else
+                    sink.line(level, message, request);
+            }
+            catch {
+                // A sink must never break the console it observes.
+            }
+        }
+    };
+    const consoleOriginals = new Map();
+    for (const method of CONSOLE_METHODS) {
+        const original = console[method];
+        const patched = function (...args) {
+            state.depth += 1;
+            try {
+                original.apply(this, args);
+            }
+            finally {
+                state.depth -= 1;
+            }
+            dispatch(CONSOLE_LEVELS[method], stripVTControlCharacters(formatConsoleArgs(args)));
+        };
+        consoleOriginals.set(method, { original, patched });
+        console[method] = patched;
+    }
+    const streamOriginals = [];
+    for (const [stream, level] of [
+        [process.stdout, "log"],
+        [process.stderr, "error"],
+    ]) {
+        const original = Reflect.get(stream, "write");
+        if (typeof original !== "function")
+            continue;
+        let partial = "";
+        const patched = function (chunk, ...rest) {
+            if (state.depth === 0) {
+                partial +=
+                    typeof chunk === "string"
+                        ? chunk
+                        : chunk instanceof Uint8Array
+                            ? new TextDecoder().decode(chunk)
+                            : "";
+                let newline = partial.indexOf("\n");
+                while (newline !== -1) {
+                    const line = stripVTControlCharacters(partial.slice(0, newline)).trimEnd();
+                    partial = partial.slice(newline + 1);
+                    if (line.length > 0) {
+                        const structured = parseCoreLogLine(line);
+                        dispatch(structured !== undefined && isDevLogLevel(structured.level)
+                            ? structured.level
+                            : level, line, structured);
+                    }
+                    newline = partial.indexOf("\n");
+                }
+                if (partial.length > MAX_PARTIAL_LINE) {
+                    dispatch(level, stripVTControlCharacters(partial));
+                    partial = "";
+                }
+            }
+            return Reflect.apply(original, this ?? stream, [chunk, ...rest]) !== false;
+        };
+        streamOriginals.push({ stream, original, patched });
+        Reflect.set(stream, "write", patched);
+    }
+    state.restore = () => {
+        for (const [method, { original, patched }] of consoleOriginals) {
+            // Only undo our own patch: a later patch layered on top stays, still forwarding to ours.
+            if (console[method] === patched)
+                console[method] = original;
+        }
+        for (const { stream, original, patched } of streamOriginals) {
+            if (Reflect.get(stream, "write") === patched)
+                Reflect.set(stream, "write", original);
+        }
+    };
+    return state;
+}
+const structuredText = (entry) => {
+    const { level: _level, message, time: _time, ...fields } = entry;
+    return Object.keys(fields).length === 0 ? message : `${message} ${JSON.stringify(fields)}`;
+};
+/** A server frame's authored position, through the map a dev plugin registered for the file it compiled. */
+const ssrRemap = (file, line, column) => {
+    const map = ssrSourceMaps().get(file.replaceAll("\\", "/"));
+    return map === undefined ? undefined : originalPosition(map, line, column);
+};
+/**
+ * Record the process's console and stream output into `feed`: every line as a log entry, and core's
+ * `unhandled request error` line additionally as an `api` error with a full Diagnostic. The one sink
+ * both dev servers and `nifra_run` use. Returns the detach function.
+ */
+export function captureInto(feed) {
+    return installCapture({
+        feedId: feed.id,
+        line: (level, message, request) => feed.recordLog(level, message, { requestId: request?.requestId }),
+        structured: (entry, request) => {
+            const level = isDevLogLevel(entry.level) ? entry.level : "log";
+            feed.recordLog(level, structuredText(entry), { requestId: request?.requestId });
+            const error = errorFromCoreLog(entry);
+            if (error === undefined)
+                return;
+            const method = typeof entry.method === "string" ? entry.method : request?.method;
+            const path = typeof entry.path === "string" ? entry.path : request?.path;
+            feed.recordError(error, {
+                category: "api",
+                requestId: request?.requestId,
+                request: method !== undefined && path !== undefined ? { method, url: path } : undefined,
+            });
+        },
+    });
+}
+//# sourceMappingURL=dev-feed.js.map