@flareapp/node 0.1.0 → 0.1.1

package/src/context/headers.ts

@@ -1,90 +0,0 @@
-import type { Attributes } from '@flareapp/core';
-
-/**
- * Case-insensitively look up a header value. Returns the first defined value
- * for the lowercased name, or undefined. Array values (rare but valid for
- * some headers) are coalesced to the first element since the consumers in
- * this package treat the value as scalar.
- */
-export function findHeader(
-    headers: Record<string, string | string[] | undefined> | undefined,
-    name: string,
-): string | undefined {
-    if (!headers) return undefined;
-    const target = name.toLowerCase();
-    for (const [key, value] of Object.entries(headers)) {
-        if (key.toLowerCase() !== target) continue;
-        if (value === undefined) continue;
-        return Array.isArray(value) ? value[0] : value;
-    }
-    return undefined;
-}
-
-/**
- * Default-redacted header names. The pattern is anchored to the FULL header
- * name (`^...$`) and case-insensitive so it catches `Authorization`,
- * `AUTHORIZATION`, `authorization`, etc. Anchoring matters: an unanchored
- * `cookie` would match `X-Some-Cookie-Hint` too, which we do NOT want — only
- * the exact header by name should be redacted by default.
- *
- * Covers the usual credential carriers (`authorization`, `cookie`, etc) plus
- * common proxy-set headers that often expose client IPs (`forwarded`,
- * `x-forwarded-for`, `x-forwarded-user`). Users add domain-specific entries
- * via `configureNode({ headerDenylist: ... })`.
- */
-export const DEFAULT_HEADER_DENYLIST =
-    /^(authorization|proxy-authorization|cookie|set-cookie|x-api-key|x-csrf-token|x-xsrf-token|x-auth-token|forwarded|x-forwarded-(?:for|user))$/i;
-
-/**
- * Combine the built-in denylist with an optional user-supplied one.
- *
- * - No custom regex          -> use the default as-is.
- * - Custom + replace = true  -> use only the custom pattern (with `g`/`y`
- *                               flags stripped so `.test()` stays stateless).
- * - Custom + replace = false -> union: `(?:default)|(?:custom)`, forcing case
- *                               insensitivity since header names are
- *                               case-insensitive over the wire.
- */
-export function resolveHeaderDenylist(custom?: RegExp, replaceDefault = false): RegExp {
-    if (!custom) return DEFAULT_HEADER_DENYLIST;
-    if (replaceDefault) return new RegExp(custom.source, custom.flags.replace(/[gy]/g, ''));
-    return new RegExp(`(?:${DEFAULT_HEADER_DENYLIST.source})|(?:${custom.source})`, 'i');
-}
-
-/**
- * Project an HTTP request `headers` object into report attributes.
- *
- * Behavior per header:
- *
- * - **Unset values** (entry exists but the value is `undefined`) are dropped
- *   entirely — `node:http` represents "header was not sent" this way.
- * - **Names are lowercased.** OTel's attribute convention uses lowercase
- *   header keys, and HTTP header names are case-insensitive anyway.
- * - **Allowlist gate.** If `headerAllowlist` is set, only headers whose
- *   lowercased name matches are emitted; everything else is silently dropped
- *   (NOT redacted, dropped). This is the strongest filter — useful for
- *   compliance scenarios where you must opt into headers explicitly.
- * - **Array values** (`set-cookie` can be `string[]`) are joined with `, ` so
- *   the emitted value is a flat string, matching the on-the-wire shape that
- *   most HTTP clients render.
- * - **Denylist redaction.** If the name matches `headerDenylist`, the value
- *   is replaced with `'[redacted]'` (the key still appears so consumers can
- *   tell the header was present).
- *
- * Output keys are `http.request.header.<lowercased-name>`, per OTel.
- */
-export function projectHeaders(
-    headers: Record<string, string | string[] | undefined> | undefined,
-    options: { headerDenylist: RegExp; headerAllowlist: RegExp | null },
-): Attributes {
-    const out: Attributes = {};
-    if (!headers) return out;
-    for (const [rawName, rawValue] of Object.entries(headers)) {
-        if (rawValue === undefined) continue;
-        const name = rawName.toLowerCase();
-        if (options.headerAllowlist && !options.headerAllowlist.test(name)) continue;
-        const value = Array.isArray(rawValue) ? rawValue.join(', ') : rawValue;
-        out[`http.request.header.${name}`] = options.headerDenylist.test(name) ? '[redacted]' : value;
-    }
-    return out;
-}

package/src/context/process.ts

@@ -1,25 +0,0 @@
-import os from 'node:os';
-
-import type { Attributes } from '@flareapp/core';
-
-/**
- * Snapshot the Node runtime + host environment at report time and project
- * into OTel-style attribute keys. Cheap (just property reads + a couple of
- * syscalls via `os`), so called per-report rather than cached; this keeps
- * `process.uptime` honest and follows the value of `os.hostname()` if it
- * changes mid-run (unlikely but free correctness).
- *
- * Keys are stable OTel resource attributes; the Flare backend recognizes them.
- */
-export function collectProcessAttributes(): Attributes {
-    return {
-        'process.runtime.name': 'nodejs',
-        'process.runtime.version': process.version,
-        'process.pid': process.pid,
-        'process.uptime': process.uptime(),
-        'host.name': os.hostname(),
-        'host.arch': process.arch,
-        'os.type': os.type(),
-        'os.version': os.release(),
-    };
-}

package/src/index.ts

@@ -1,27 +0,0 @@
-import { NodeFlare } from './Flare';
-
-export const flare = new NodeFlare();
-
-export { NodeFlare } from './Flare';
-export type { RequestContext, User, FatalMode, NodeOptions } from './types';
-export { Flare, Scope, GlobalScopeProvider, NullFileReader } from '@flareapp/core';
-export type {
-    AttributeValue,
-    Attributes,
-    Config,
-    ContextCollector,
-    EntryPointHandler,
-    FileReader,
-    Framework,
-    Glow,
-    MessageLevel,
-    OverriddenGrouping,
-    Report,
-    ScopeProvider,
-    SdkInfo,
-    SpanEvent,
-    StackFrame,
-} from '@flareapp/core';
-export { convertToError, DEFAULT_URL_DENYLIST, redactUrlQuery, resolveDenylist } from '@flareapp/core';
-
-export { NodeScope } from './scope/NodeScope';

package/src/process/fatal.ts

@@ -1,54 +0,0 @@
-import type { Flare } from '@flareapp/core';
-
-import type { FatalMode } from '../types';
-
-type FatalOptions = {
-    uncaughtExceptionMode: FatalMode;
-    unhandledRejectionMode: FatalMode;
-    shutdownTimeoutMs: number;
-};
-
-export function buildFatalCallbacks(
-    flare: Flare,
-    getOpts: () => FatalOptions,
-    exit: (code: number) => void = process.exit.bind(process),
-) {
-    return {
-        async onUncaught(err: unknown, origin: string): Promise<void> {
-            const opts = getOpts();
-            if (opts.uncaughtExceptionMode === 'report-and-exit') {
-                process.exitCode = 1;
-            }
-            const error = err instanceof Error ? err : new Error(String(err));
-            try {
-                await flare.report(error, { 'process.uncaught_exception.origin': origin });
-            } catch {
-                // swallow
-            }
-            // Only drain other in-flight reports when we're about to exit. In
-            // 'report' mode the process keeps running, so those reports settle
-            // on their own and flushing here would just waste time. Mirrors
-            // onRejection.
-            if (opts.uncaughtExceptionMode === 'report-and-exit') {
-                await flare.flush(opts.shutdownTimeoutMs);
-                exit(1);
-            }
-        },
-        async onRejection(reason: unknown): Promise<void> {
-            const opts = getOpts();
-            if (opts.unhandledRejectionMode === 'report-and-exit') {
-                process.exitCode = 1;
-            }
-            const error = reason instanceof Error ? reason : new Error(String(reason));
-            try {
-                await flare.report(error);
-            } catch {
-                // swallow
-            }
-            if (opts.unhandledRejectionMode === 'report-and-exit') {
-                await flare.flush(opts.shutdownTimeoutMs);
-                exit(1);
-            }
-        },
-    };
-}

package/src/process/handlers.ts

@@ -1,109 +0,0 @@
-import type { FatalMode } from '../types';
-
-type Callbacks = {
-    onUncaught: (err: unknown, origin: string) => void;
-    onRejection: (reason: unknown) => void;
-};
-
-/**
- * Owns the lifecycle of the two process-level error listeners that capture
- * fatal failures and feed them to Flare:
- *
- * - `process.on('uncaughtException', ...)`
- * - `process.on('unhandledRejection', ...)`
- *
- * The manager has two responsibilities:
- *
- * 1. **Reconcile listener state with intent.** Given the current `FatalMode`
- *    for each event (`'off' | 'report' | 'report-and-exit'`), make the actual
- *    listener attachment match: attach when it should be attached but isn't,
- *    detach when it shouldn't be attached but is, no-op when already in the
- *    desired state. This is idempotent — calling `reconcile(...)` repeatedly
- *    with the same options is safe.
- * 2. **Tear down on demand.** `detach()` removes both listeners regardless of
- *    intent, for tests and graceful shutdown.
- *
- * Why keep this separate from `NodeFlare`: the attach/detach logic is purely
- * about Node `process` events and contains no Flare semantics. Isolating it
- * makes it trivial to test (the test suite drives `reconcile()` directly with
- * stub callbacks and asserts on `process.listeners(...)`) and keeps
- * `NodeFlare` focused on report assembly + user-facing API.
- */
-export class ProcessHandlerManager {
-    /** The currently-attached listener for `uncaughtException`, or `null`. */
-    private uncaughtHandler: ((err: unknown, origin: string) => void) | null = null;
-    /** The currently-attached listener for `unhandledRejection`, or `null`. */
-    private rejectionHandler: ((reason: unknown) => void) | null = null;
-
-    constructor(private cbs: Callbacks) {}
-
-    /**
-     * Bring the attached listeners into agreement with the supplied modes.
-     * Idempotent: when current state already matches intent, this is a no-op.
-     */
-    reconcile(opts: { uncaughtExceptionMode: FatalMode; unhandledRejectionMode: FatalMode }): void {
-        this.reconcileOne(
-            'uncaughtException',
-            opts.uncaughtExceptionMode,
-            () => this.uncaughtHandler,
-            (h) => {
-                this.uncaughtHandler = h;
-            },
-            (err, origin) => this.cbs.onUncaught(err, origin as string),
-        );
-        this.reconcileOne(
-            'unhandledRejection',
-            opts.unhandledRejectionMode,
-            () => this.rejectionHandler,
-            (h) => {
-                this.rejectionHandler = h;
-            },
-            (reason) => this.cbs.onRejection(reason),
-        );
-    }
-
-    /**
-     * Remove both listeners regardless of current intent. Used by tests and by
-     * `NodeFlare.removeProcessListeners()`. Safe to call when nothing is
-     * attached.
-     */
-    detach(): void {
-        if (this.uncaughtHandler) {
-            process.off('uncaughtException', this.uncaughtHandler as any);
-            this.uncaughtHandler = null;
-        }
-        if (this.rejectionHandler) {
-            process.off('unhandledRejection', this.rejectionHandler as any);
-            this.rejectionHandler = null;
-        }
-    }
-
-    /**
-     * Generic attach/detach for one event. The `get`/`set` closures let us
-     * share this body between the two events while still mutating distinct
-     * fields (`uncaughtHandler` vs `rejectionHandler`).
-     *
-     * Truth table:
-     * - intent off, currently attached -> detach
-     * - intent off, not attached       -> no-op
-     * - intent on,  currently attached -> no-op (already correct)
-     * - intent on,  not attached       -> attach
-     */
-    private reconcileOne(
-        event: 'uncaughtException' | 'unhandledRejection',
-        mode: FatalMode,
-        get: () => ((...args: any[]) => void) | null,
-        set: (h: ((...args: any[]) => void) | null) => void,
-        impl: (...args: any[]) => void,
-    ): void {
-        const current = get();
-        const wants = mode !== 'off';
-        if (wants && !current) {
-            set(impl);
-            process.on(event, impl as any);
-        } else if (!wants && current) {
-            process.off(event, current as any);
-            set(null);
-        }
-    }
-}

package/src/scope/AsyncLocalStorageScopeProvider.ts

@@ -1,86 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-
-import type { ScopeProvider } from '@flareapp/core';
-
-import type { RequestContext, User } from '../types';
-import { NodeScope } from './NodeScope';
-
-/**
- * `ScopeProvider` implementation that gives every in-flight request its own
- * `NodeScope`, isolated from concurrent requests.
- *
- * Built on Node's `node:async_hooks#AsyncLocalStorage`: when code runs inside
- * `als.run(scope, fn)`, every `als.getStore()` call from within `fn` (and any
- * async work `fn` awaits, including timers, promises, `process.nextTick`, etc)
- * returns that `scope`. Outside any `als.run` call, `getStore()` returns
- * `undefined`. This is the same primitive that lets observability libraries
- * propagate trace context across async boundaries without manual plumbing.
- *
- * Two "kinds of read" surfaced separately:
- *
- * - `active()` — never returns null. The internal read used by `Flare` for
- *   every glow, attribute set, and report. When called inside `runWithContext`,
- *   returns the per-request `NodeScope`. Outside, returns a shared `fallback`
- *   scope so glows/attributes/reports issued outside any request still have
- *   somewhere to land (process-level reports, startup errors, scheduled jobs).
- * - `getContext()` — public debug helper. Returns `null` outside any
- *   `runWithContext`, so consumers can distinguish "I am inside a request" from
- *   "I am not". The fallback is intentionally NOT exposed here.
- *
- * The fallback is also a per-instance `NodeScope` so that writes from outside
- * a request scope persist for subsequent outside-scope reports.
- */
-export class AsyncLocalStorageScopeProvider implements ScopeProvider {
-    private als = new AsyncLocalStorage<NodeScope>();
-    private fallback = new NodeScope();
-
-    /**
-     * Internal: returns the per-request scope when inside `runWithContext`,
-     * or the shared fallback otherwise. Always returns a real `NodeScope`.
-     */
-    active(): NodeScope {
-        return this.als.getStore() ?? this.fallback;
-    }
-
-    /**
-     * Public: returns the per-request scope when inside `runWithContext`, or
-     * `null` otherwise. Useful for assertions like "am I in a request?".
-     */
-    getContext(): NodeScope | null {
-        return this.als.getStore() ?? null;
-    }
-
-    /**
-     * Open a fresh request scope around `fn` and run it. Every async hop
-     * inside `fn` (awaits, timers, promise chains) sees the same scope via
-     * `active()`/`getContext()`; concurrent calls each get their own.
-     *
-     * `request` is shallow-cloned so later edits to the caller's object do not
-     * leak into the stored scope.
-     */
-    runWithContext<T>(request: RequestContext, fn: () => T): T {
-        const scope = new NodeScope();
-        scope.request = { ...request };
-        return this.als.run(scope, fn);
-    }
-
-    /**
-     * Patch the current scope's `request` shape. When called inside
-     * `runWithContext`, the patch is visible to all subsequent reads from
-     * within the same request chain. When called outside, the patch lands on
-     * the fallback scope.
-     */
-    mergeContext(partial: Partial<RequestContext>): void {
-        const scope = this.als.getStore() ?? this.fallback;
-        scope.request = { ...scope.request, ...partial };
-    }
-
-    /**
-     * Set the authenticated user on the current scope. Same in-scope vs
-     * fallback semantics as `mergeContext`.
-     */
-    setUser(user: User | null): void {
-        const scope = this.als.getStore() ?? this.fallback;
-        scope.user = user;
-    }
-}

package/src/scope/NodeScope.ts

@@ -1,8 +0,0 @@
-import { Scope } from '@flareapp/core';
-
-import type { RequestContext, User } from '../types';
-
-export class NodeScope extends Scope {
-    request: RequestContext = {};
-    user: User | null = null;
-}

package/src/stacktrace/DiskFileReader.ts

@@ -1,57 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-
-import type { FileReader } from '@flareapp/core';
-
-/**
- * Node `FileReader` implementation that reads source files from disk.
- *
- * Wired into `@flareapp/node`'s singleton so the stack-trace builder can pull
- * source for each frame and render a snippet. On the server the frame's "URL"
- * is usually a local path (e.g. `/app/dist/server.js`) or a `file://` URL
- * (from `import.meta.url`), so we resolve straight off disk instead of going
- * over the network.
- *
- * Safety gates:
- *
- * 1. **Local-path allowlist.** Only `file://` URLs and absolute filesystem
- *    paths (POSIX `/foo`, Windows `C:\foo` or `\\server\share\foo`) are
- *    accepted. HTTP URLs and relative paths return `null` immediately. We
- *    refuse to read anything that does not unambiguously identify a local
- *    file — no surprise traversal, no following http stack frames in a
- *    server build, no relative-path ambiguity around the current working
- *    directory.
- * 2. **Catch-all.** Missing files, permission errors, and any other failure
- *    return `null`. The `read()` contract returns `null` on every failure
- *    path and never throws.
- *
- * `fileURLToPath` is used when the input is a `file://` URL so we hand
- * `readFile` a real OS path. Otherwise the URL IS already a path and is
- * passed through unchanged.
- */
-export class DiskFileReader implements FileReader {
-    async read(url: string): Promise<string | null> {
-        if (!isLocalFileUrl(url)) return null;
-        try {
-            const path = /^file:\/\//i.test(url) ? fileURLToPath(url) : url;
-            return await readFile(path, 'utf-8');
-        } catch {
-            return null;
-        }
-    }
-}
-
-/**
- * Return true when `url` is something we are willing to treat as a local
- * file. Matches four shapes:
- *
- * - `file://...` URLs (any casing of the scheme)
- * - POSIX absolute paths starting with `/`
- * - Windows drive-letter paths like `C:\foo` or `c:/foo`
- * - Windows UNC paths starting with `\\`
- *
- * Anything else (relative paths, http, data, blob, etc) is rejected.
- */
-function isLocalFileUrl(url: string): boolean {
-    return /^file:\/\//i.test(url) || url.startsWith('/') || /^[a-z]:[\\/]/i.test(url) || url.startsWith('\\\\');
-}

package/src/types.ts

@@ -1,37 +0,0 @@
-export type RequestContext = {
-    method?: string;
-    path?: string;
-    url?: string;
-    headers?: Record<string, string | string[] | undefined>;
-    body?: unknown;
-};
-
-export type User = {
-    id?: string | number;
-    email?: string;
-    username?: string;
-    ipAddress?: string;
-};
-
-export type FatalMode = 'off' | 'report' | 'report-and-exit';
-
-export type NodeOptions = {
-    uncaughtExceptionMode?: FatalMode;
-    unhandledRejectionMode?: FatalMode;
-    shutdownTimeoutMs?: number;
-    headerDenylist?: RegExp;
-    headerAllowlist?: RegExp | null;
-    replaceDefaultHeaderDenylist?: boolean;
-    captureRequestBody?: boolean;
-    bodyMaxBytes?: number;
-    bodyAllowedContentTypes?: RegExp;
-    bodyKeyDenylist?: RegExp;
-};
-
-export type ResolvedNodeOptions = Required<
-    Omit<NodeOptions, 'headerDenylist' | 'headerAllowlist' | 'bodyKeyDenylist'>
-> & {
-    headerDenylist: RegExp;
-    headerAllowlist: RegExp | null;
-    bodyKeyDenylist: RegExp;
-};

package/tests/asyncScopeProvider.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { AsyncLocalStorageScopeProvider } from '../src/scope/AsyncLocalStorageScopeProvider';
-import { NodeScope } from '../src/scope/NodeScope';
-
-describe('AsyncLocalStorageScopeProvider', () => {
-    it('falls back to a shared NodeScope outside runWithContext', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const a = provider.active();
-        const b = provider.active();
-        expect(a).toBeInstanceOf(NodeScope);
-        expect(a).toBe(b);
-    });
-
-    it('returns null from getContext outside runWithContext', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        expect(provider.getContext()).toBeNull();
-    });
-
-    it('isolates scopes across runWithContext calls', async () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const results: Array<string | undefined> = [];
-
-        async function workload(label: string) {
-            return provider.runWithContext({ path: `/${label}` }, async () => {
-                await new Promise((r) => setTimeout(r, Math.random() * 20));
-                results.push(provider.active().request.path);
-            });
-        }
-
-        await Promise.all([workload('a'), workload('b'), workload('c')]);
-        results.sort();
-        expect(results).toEqual(['/a', '/b', '/c']);
-    });
-
-    it('mergeContext patches the active scope', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        provider.runWithContext({ method: 'GET' }, () => {
-            provider.mergeContext({ path: '/foo' });
-            expect(provider.active().request).toEqual({ method: 'GET', path: '/foo' });
-        });
-    });
-});

package/tests/body.test.ts

@@ -1,129 +0,0 @@
-import { Readable } from 'node:stream';
-
-import { describe, expect, it } from 'vitest';
-
-import { captureBody, DEFAULT_BODY_CONTENT_TYPES, DEFAULT_BODY_KEY_DENYLIST } from '../src/context/body';
-
-const opts = {
-    bodyAllowedContentTypes: DEFAULT_BODY_CONTENT_TYPES,
-    bodyKeyDenylist: DEFAULT_BODY_KEY_DENYLIST,
-    bodyMaxBytes: 16_384,
-};
-
-describe('captureBody', () => {
-    it('returns null for empty body', () => {
-        expect(captureBody(undefined, 'application/json', opts)).toBeNull();
-    });
-
-    it('parses JSON body and redacts password key', () => {
-        const out = captureBody('{"user":"x","password":"secret"}', 'application/json', opts);
-        const parsed = JSON.parse(out!);
-        expect(parsed).toEqual({ user: 'x', password: '[redacted]' });
-    });
-
-    it('accepts content-type with parameters', () => {
-        const out = captureBody('{"a":1}', 'application/json; charset=utf-8', opts);
-        expect(out).toBe('{"a":1}');
-    });
-
-    it('normalizes the media type so a strict custom regex matches parameterized headers', () => {
-        const strict = { ...opts, bodyAllowedContentTypes: /^application\/json$/ };
-        // Anchored regex would reject the raw header `application/json; charset=utf-8`;
-        // matchesContentType strips params and lowercases first, so it matches.
-        expect(captureBody('{"a":1}', 'application/json; charset=utf-8', strict)).toBe('{"a":1}');
-        expect(captureBody('{"a":1}', 'APPLICATION/JSON', strict)).toBe('{"a":1}');
-    });
-
-    it('rejects content-types not in allowlist', () => {
-        expect(captureBody('hello', 'text/plain', opts)).toBeNull();
-    });
-
-    it('decodes Buffer input as UTF-8', () => {
-        const out = captureBody(Buffer.from('{"k":1}'), 'application/json', opts);
-        expect(out).toBe('{"k":1}');
-    });
-
-    it('skips content-type check when body is already an object', () => {
-        const out = captureBody({ a: 1, token: 'x' }, undefined, opts);
-        expect(JSON.parse(out!)).toEqual({ a: 1, token: '[redacted]' });
-    });
-
-    it('handles URLSearchParams', () => {
-        const out = captureBody(new URLSearchParams({ a: '1', secret: 'x' }), undefined, opts);
-        expect(JSON.parse(out!)).toEqual({ a: '1', secret: '[redacted]' });
-    });
-
-    it('truncates over bodyMaxBytes', () => {
-        const big = { v: 'x'.repeat(20_000) };
-        const out = captureBody(big, undefined, { ...opts, bodyMaxBytes: 100 });
-        expect(Buffer.byteLength(out!, 'utf8')).toBeLessThanOrEqual(100);
-        expect(out!.endsWith('…[truncated]')).toBe(true);
-    });
-
-    it('truncates by UTF-8 byte length, not character length, for multi-byte payloads', () => {
-        // Three-byte char (CJK) repeated. 200 chars = 600 UTF-8 bytes.
-        const big = { v: '漢'.repeat(200) };
-        const out = captureBody(big, undefined, { ...opts, bodyMaxBytes: 100 });
-        expect(out).not.toBeNull();
-        expect(Buffer.byteLength(out!, 'utf8')).toBeLessThanOrEqual(100);
-        expect(out!.endsWith('…[truncated]')).toBe(true);
-    });
-
-    it('never leaves a partial multi-byte sequence at the cut', () => {
-        const big = { v: '漢'.repeat(200) };
-        const out = captureBody(big, undefined, { ...opts, bodyMaxBytes: 50 });
-        // Decoded buffer must round-trip cleanly (no Unicode replacement char).
-        expect(out!.includes('�')).toBe(false);
-    });
-
-    it('emits only suffix when budget is too small', () => {
-        const big = { v: 'x'.repeat(100) };
-        const out = captureBody(big, undefined, { ...opts, bodyMaxBytes: 5 });
-        // 5 bytes can't fit 14-byte suffix + any payload. Result should be the
-        // suffix truncated to 5 bytes, staying within the byte budget.
-        expect(Buffer.byteLength(out!, 'utf8')).toBeLessThanOrEqual(5);
-    });
-
-    it('ASCII-only path still truncates at byte budget including suffix', () => {
-        const big = { v: 'x'.repeat(200) };
-        const out = captureBody(big, undefined, { ...opts, bodyMaxBytes: 50 });
-        expect(Buffer.byteLength(out!, 'utf8')).toBeLessThanOrEqual(50);
-        expect(out!.endsWith('…[truncated]')).toBe(true);
-    });
-
-    it('handles circular references', () => {
-        const obj: any = { a: 1 };
-        obj.self = obj;
-        const out = captureBody(obj, undefined, opts);
-        expect(out).toContain('"[Circular]"');
-    });
-
-    it('skips Node streams', () => {
-        const stream = Readable.from(['x']);
-        expect(captureBody(stream, undefined, opts)).toBeNull();
-    });
-
-    it('skips ArrayBuffer and typed arrays', () => {
-        expect(captureBody(new ArrayBuffer(8), undefined, opts)).toBeNull();
-        expect(captureBody(new Uint8Array([1, 2, 3]), undefined, opts)).toBeNull();
-    });
-
-    it('skips FormData', () => {
-        const fd = new FormData();
-        fd.append('a', '1');
-        expect(captureBody(fd, undefined, opts)).toBeNull();
-    });
-
-    it('skips class instances with non-Object prototypes', () => {
-        class User {
-            constructor(public id: string) {}
-        }
-        expect(captureBody(new User('u1'), undefined, opts)).toBeNull();
-    });
-
-    it('still accepts plain objects and arrays', () => {
-        expect(captureBody({ a: 1 }, undefined, opts)).toBe('{"a":1}');
-        expect(captureBody([1, 2, 3], undefined, opts)).toBe('[1,2,3]');
-        expect(captureBody(Object.create(null), undefined, opts)).toBe('{}');
-    });
-});