@flareapp/node 0.1.0 → 0.1.1

package/tests/diskFileReader.test.ts

@@ -1,36 +0,0 @@
-import { writeFileSync, mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-import { describe, expect, it } from 'vitest';
-
-import { DiskFileReader } from '../src/stacktrace/DiskFileReader';
-
-describe('DiskFileReader', () => {
-    it('reads a real file from disk by absolute path', async () => {
-        const dir = mkdtempSync(join(tmpdir(), 'flare-test-'));
-        const file = join(dir, 'sample.js');
-        writeFileSync(file, 'hello\nworld');
-        const reader = new DiskFileReader();
-        expect(await reader.read(file)).toBe('hello\nworld');
-    });
-
-    it('reads a file:// URL', async () => {
-        const dir = mkdtempSync(join(tmpdir(), 'flare-test-'));
-        const file = join(dir, 'sample.js');
-        writeFileSync(file, 'x');
-        const reader = new DiskFileReader();
-        expect(await reader.read(pathToFileURL(file).href)).toBe('x');
-    });
-
-    it('returns null for http urls', async () => {
-        const reader = new DiskFileReader();
-        expect(await reader.read('https://example.com/x.js')).toBeNull();
-    });
-
-    it('returns null for missing files', async () => {
-        const reader = new DiskFileReader();
-        expect(await reader.read('/definitely/not/a/file.js')).toBeNull();
-    });
-});

package/tests/fatalHandlers.test.ts

@@ -1,140 +0,0 @@
-import { Flare, Api } from '@flareapp/core';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { buildFatalCallbacks } from '../src/process/fatal';
-
-function fakeFlare(): { flare: Flare; sent: any[] } {
-    const sent: any[] = [];
-    const api = new Api();
-    api.report = (report: any) => {
-        sent.push(report);
-        return Promise.resolve();
-    };
-    const flare = new Flare(api);
-    flare.light('k');
-    return { flare, sent };
-}
-
-afterEach(() => {
-    // Reset exitCode so one test doesn't bleed into the next
-    process.exitCode = undefined;
-});
-
-describe('fatal callbacks', () => {
-    it('uncaught: awaits full report pipeline before resolving', async () => {
-        const { flare, sent } = fakeFlare();
-        const exit = vi.fn();
-        const { onUncaught } = buildFatalCallbacks(
-            flare,
-            () => ({
-                uncaughtExceptionMode: 'report-and-exit',
-                unhandledRejectionMode: 'off',
-                shutdownTimeoutMs: 1000,
-            }),
-            exit,
-        );
-        await onUncaught(new Error('boom'), 'uncaughtException');
-        expect(sent.length).toBe(1);
-        expect(sent[0].attributes['process.uncaught_exception.origin']).toBe('uncaughtException');
-        expect(exit).toHaveBeenCalledWith(1);
-    });
-
-    it('uncaught: does NOT exit when mode is report', async () => {
-        const { flare, sent } = fakeFlare();
-        const exit = vi.fn();
-        const { onUncaught } = buildFatalCallbacks(
-            flare,
-            () => ({
-                uncaughtExceptionMode: 'report',
-                unhandledRejectionMode: 'off',
-                shutdownTimeoutMs: 1000,
-            }),
-            exit,
-        );
-        await onUncaught(new Error('boom'), 'uncaughtException');
-        expect(sent.length).toBe(1);
-        expect(exit).not.toHaveBeenCalled();
-    });
-
-    it('unhandled rejection: coerces non-Error reason', async () => {
-        const { flare, sent } = fakeFlare();
-        const exit = vi.fn();
-        const { onRejection } = buildFatalCallbacks(
-            flare,
-            () => ({
-                uncaughtExceptionMode: 'off',
-                unhandledRejectionMode: 'report',
-                shutdownTimeoutMs: 1000,
-            }),
-            exit,
-        );
-        await onRejection('a string reason');
-        expect(sent.length).toBe(1);
-        expect(sent[0].message).toBe('a string reason');
-        expect(exit).not.toHaveBeenCalled();
-    });
-
-    it('uncaught: sets process.exitCode=1 synchronously before awaiting report', async () => {
-        const { flare } = fakeFlare();
-        let exitCodeDuringReport: number | string | undefined;
-        const api = new Api();
-        api.report = () => {
-            exitCodeDuringReport = process.exitCode;
-            return Promise.resolve();
-        };
-        flare.api = api;
-
-        const exit = vi.fn();
-        const { onUncaught } = buildFatalCallbacks(
-            flare,
-            () => ({
-                uncaughtExceptionMode: 'report-and-exit',
-                unhandledRejectionMode: 'off',
-                shutdownTimeoutMs: 1000,
-            }),
-            exit,
-        );
-        await onUncaught(new Error('boom'), 'uncaughtException');
-        expect(exitCodeDuringReport).toBe(1);
-    });
-
-    it('rejection: sets process.exitCode=1 synchronously before awaiting report', async () => {
-        const { flare } = fakeFlare();
-        let exitCodeDuringReport: number | string | undefined;
-        const api = new Api();
-        api.report = () => {
-            exitCodeDuringReport = process.exitCode;
-            return Promise.resolve();
-        };
-        flare.api = api;
-
-        const exit = vi.fn();
-        const { onRejection } = buildFatalCallbacks(
-            flare,
-            () => ({
-                uncaughtExceptionMode: 'off',
-                unhandledRejectionMode: 'report-and-exit',
-                shutdownTimeoutMs: 1000,
-            }),
-            exit,
-        );
-        await onRejection(new Error('rejected'));
-        expect(exitCodeDuringReport).toBe(1);
-    });
-
-    it('uncaught: does NOT set process.exitCode when mode is report', async () => {
-        const { flare } = fakeFlare();
-        const exit = vi.fn();
-        const { onUncaught } = buildFatalCallbacks(
-            flare,
-            () => ({
-                uncaughtExceptionMode: 'report',
-                unhandledRejectionMode: 'off',
-                shutdownTimeoutMs: 1000,
-            }),
-            exit,
-        );
-        await onUncaught(new Error('boom'), 'uncaughtException');
-        expect(process.exitCode).toBeUndefined();
-    });
-});

package/tests/flush.test.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { flare } from '../src';
-
-describe('Node flare.flush', () => {
-    it('resolves quickly when there is nothing in flight', async () => {
-        const start = Date.now();
-        await flare.flush(1000);
-        expect(Date.now() - start).toBeLessThan(50);
-    });
-});

package/tests/headers.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { DEFAULT_HEADER_DENYLIST, findHeader, projectHeaders } from '../src/context/headers';
-
-describe('projectHeaders', () => {
-    it('emits each header as http.request.header.<lowercase-name>', () => {
-        const attrs = projectHeaders(
-            { 'Content-Type': 'application/json', 'X-Foo': 'bar' },
-            {
-                headerDenylist: DEFAULT_HEADER_DENYLIST,
-                headerAllowlist: null,
-            },
-        );
-        expect(attrs['http.request.header.content-type']).toBe('application/json');
-        expect(attrs['http.request.header.x-foo']).toBe('bar');
-    });
-
-    it('redacts default-denylisted headers', () => {
-        const attrs = projectHeaders(
-            { Authorization: 'Bearer xyz', Cookie: 'sid=1' },
-            {
-                headerDenylist: DEFAULT_HEADER_DENYLIST,
-                headerAllowlist: null,
-            },
-        );
-        expect(attrs['http.request.header.authorization']).toBe('[redacted]');
-        expect(attrs['http.request.header.cookie']).toBe('[redacted]');
-    });
-
-    it('allowlist filters out non-allowed headers entirely', () => {
-        const attrs = projectHeaders(
-            { 'X-Foo': 'bar', 'X-Baz': 'qux' },
-            {
-                headerDenylist: DEFAULT_HEADER_DENYLIST,
-                headerAllowlist: /^x-foo$/i,
-            },
-        );
-        expect(attrs['http.request.header.x-foo']).toBe('bar');
-        expect(attrs['http.request.header.x-baz']).toBeUndefined();
-    });
-
-    it('coalesces array values', () => {
-        const attrs = projectHeaders(
-            { 'X-Foo': ['a', 'b'] as any },
-            {
-                headerDenylist: DEFAULT_HEADER_DENYLIST,
-                headerAllowlist: null,
-            },
-        );
-        expect(attrs['http.request.header.x-foo']).toBe('a, b');
-    });
-});
-
-describe('findHeader', () => {
-    it('returns undefined when headers is undefined', () => {
-        expect(findHeader(undefined, 'content-type')).toBeUndefined();
-    });
-
-    it('finds header with exact lowercase key', () => {
-        expect(findHeader({ 'content-type': 'application/json' }, 'content-type')).toBe('application/json');
-    });
-
-    it('finds header with uppercase key', () => {
-        expect(findHeader({ 'CONTENT-TYPE': 'application/json' }, 'content-type')).toBe('application/json');
-    });
-
-    it('finds header with mixed case key', () => {
-        expect(findHeader({ 'Content-type': 'application/json; charset=utf-8' }, 'content-type')).toBe(
-            'application/json; charset=utf-8',
-        );
-    });
-
-    it('coalesces array values to first element', () => {
-        expect(findHeader({ 'content-type': ['application/json', 'text/plain'] as any }, 'content-type')).toBe(
-            'application/json',
-        );
-    });
-
-    it('returns undefined when header is not present', () => {
-        expect(findHeader({ 'x-foo': 'bar' }, 'content-type')).toBeUndefined();
-    });
-
-    it('returns undefined when header value is undefined', () => {
-        expect(findHeader({ 'content-type': undefined }, 'content-type')).toBeUndefined();
-    });
-});

package/tests/integration.test.ts

@@ -1,63 +0,0 @@
-import { createServer, type Server } from 'node:http';
-
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-
-import { startFakeFlareServer } from '../../../e2e/fake-flare-server';
-import type { FakeFlareServer } from '../../../e2e/fake-flare-server';
-
-let fakeFlareServer: FakeFlareServer;
-
-beforeAll(async () => {
-    fakeFlareServer = await startFakeFlareServer();
-});
-
-afterAll(async () => {
-    await fakeFlareServer?.stop();
-});
-
-describe('Node SDK integration', () => {
-    it('reports an error through a real HTTP server', async () => {
-        const { flare } = await import('../src');
-        flare.removeProcessListeners();
-        flare.configureNode({ uncaughtExceptionMode: 'off', unhandledRejectionMode: 'off' });
-        flare.configure({ ingestUrl: `${fakeFlareServer.url}/api/reports` });
-        flare.light('test-key');
-
-        fakeFlareServer.reset();
-
-        let captured = false;
-        const app: Server = createServer((req, res) => {
-            flare.runWithContext({ method: req.method!, path: req.url! }, async () => {
-                if (req.url === '/boom') {
-                    try {
-                        throw new Error('integration-boom');
-                    } catch (e) {
-                        await flare.report(e as Error);
-                        captured = true;
-                    }
-                }
-                res.end('ok');
-            });
-        });
-
-        await new Promise<void>((r) => app.listen(0, r));
-        const port = (app.address() as { port: number }).port;
-
-        await fetch(`http://localhost:${port}/boom`);
-        await flare.flush(1500);
-
-        expect(captured).toBe(true);
-
-        const reports = fakeFlareServer.reports();
-        expect(reports.length).toBe(1);
-
-        const body = reports[0].bodyJson as Record<string, unknown>;
-        expect(body.message).toBe('integration-boom');
-
-        const attributes = body.attributes as Record<string, unknown>;
-        expect(attributes['http.request.method']).toBe('GET');
-        expect(attributes['url.path']).toBe('/boom');
-
-        await new Promise<void>((r) => app.close(() => r()));
-    });
-});

package/tests/lifecycle.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { flare } from '../src';
-import { NodeFlare } from '../src/Flare';
-
-describe('Node singleton lifecycle', () => {
-    it('configureNode before light: no listeners until light', () => {
-        flare.removeProcessListeners();
-        const before = process.listeners('uncaughtException').length;
-        flare.configureNode({ uncaughtExceptionMode: 'report' });
-        expect(process.listeners('uncaughtException').length).toBe(before); // not lit yet
-        flare.light('k');
-        expect(process.listeners('uncaughtException').length).toBe(before + 1);
-        flare.removeProcessListeners();
-    });
-
-    it('configureNode after light: dynamically attaches and detaches', () => {
-        flare.removeProcessListeners();
-        flare.configureNode({ uncaughtExceptionMode: 'off' });
-        flare.light('k');
-        const baseline = process.listeners('uncaughtException').length;
-        flare.configureNode({ uncaughtExceptionMode: 'report' });
-        expect(process.listeners('uncaughtException').length).toBe(baseline + 1);
-        flare.configureNode({ uncaughtExceptionMode: 'off' });
-        expect(process.listeners('uncaughtException').length).toBe(baseline);
-        flare.removeProcessListeners();
-    });
-
-    it('runWithContext isolates request scope', () => {
-        const seen: Array<string | undefined> = [];
-        flare.runWithContext({ path: '/a' }, () => {
-            seen.push(flare.getContext()?.request.path);
-        });
-        flare.runWithContext({ path: '/b' }, () => {
-            seen.push(flare.getContext()?.request.path);
-        });
-        expect(flare.getContext()).toBeNull();
-        expect(seen).toEqual(['/a', '/b']);
-    });
-
-    it('removeProcessListeners then light reattaches handlers', () => {
-        const instance = new NodeFlare();
-        instance.removeProcessListeners();
-        instance.configureNode({ uncaughtExceptionMode: 'report' });
-        instance.light('k');
-        const after_first_light = process.listeners('uncaughtException').length;
-        expect(after_first_light).toBeGreaterThanOrEqual(1);
-        const baseline = after_first_light - 1;
-        instance.removeProcessListeners();
-        expect(process.listeners('uncaughtException').length).toBe(baseline);
-        instance.light('k');
-        expect(process.listeners('uncaughtException').length).toBe(baseline + 1);
-        instance.removeProcessListeners();
-    });
-
-    it('supports subclass fluent chaining', () => {
-        const instance = new NodeFlare();
-        // Type-only check: ensure subclass methods remain chainable
-        instance.configure({ stage: 'prod' }).configureNode({ uncaughtExceptionMode: 'off' });
-        instance.removeProcessListeners();
-    });
-
-    it('configureNode({ headerAllowlist: null }) clears a previously set allowlist', () => {
-        const instance = new NodeFlare();
-        instance.configureNode({ headerAllowlist: /^x-foo$/i });
-        expect((instance as any).nodeOptions.headerAllowlist).not.toBeNull();
-        instance.configureNode({ headerAllowlist: null });
-        expect((instance as any).nodeOptions.headerAllowlist).toBeNull();
-        instance.removeProcessListeners();
-    });
-});

package/tests/nodeContextCollector.test.ts

@@ -1,106 +0,0 @@
-import { DEFAULT_URL_DENYLIST } from '@flareapp/core';
-import { describe, expect, it } from 'vitest';
-
-import { DEFAULT_BODY_CONTENT_TYPES, DEFAULT_BODY_KEY_DENYLIST } from '../src/context/body';
-import { makeNodeContextCollector } from '../src/context/collectNode';
-import { DEFAULT_HEADER_DENYLIST } from '../src/context/headers';
-import { AsyncLocalStorageScopeProvider } from '../src/scope/AsyncLocalStorageScopeProvider';
-
-const baseOpts = {
-    headerDenylist: DEFAULT_HEADER_DENYLIST,
-    headerAllowlist: null,
-    captureRequestBody: false,
-    bodyAllowedContentTypes: DEFAULT_BODY_CONTENT_TYPES,
-    bodyKeyDenylist: DEFAULT_BODY_KEY_DENYLIST,
-    bodyMaxBytes: 16_384,
-};
-
-describe('Node ContextCollector', () => {
-    it('emits process attributes when called outside a scope', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => baseOpts);
-        const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-        expect(attrs['process.runtime.name']).toBe('nodejs');
-        expect(attrs['flare.entry_point.type']).toBe('server');
-    });
-
-    it('projects request.path into url.path + url.query', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => baseOpts);
-        provider.runWithContext({ method: 'POST', path: '/foo?bar=1&token=x' }, () => {
-            const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-            expect(attrs['http.request.method']).toBe('POST');
-            expect(attrs['url.path']).toBe('/foo');
-            expect(attrs['url.query']).toBe('bar=1&token=[redacted]');
-        });
-    });
-
-    it('projects request.url through redactUrlQuery into url.full', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => baseOpts);
-        provider.runWithContext({ url: 'https://x.test/a?password=hunter2' }, () => {
-            const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-            expect(attrs['url.full']).toBe('https://x.test/a?password=[redacted]');
-        });
-    });
-
-    it('projects user fields with OTel keys', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => baseOpts);
-        provider.runWithContext({}, () => {
-            provider.setUser({ id: 'u1', email: 'a@b.c', ipAddress: '1.2.3.4' });
-            const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-            expect(attrs['enduser.id']).toBe('u1');
-            expect(attrs['enduser.email']).toBe('a@b.c');
-            expect(attrs['client.address']).toBe('1.2.3.4');
-        });
-    });
-
-    it('respects captureRequestBody=false', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => baseOpts);
-        provider.runWithContext({ body: { a: 1 }, headers: { 'content-type': 'application/json' } }, () => {
-            const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-            expect(attrs['http.request.body']).toBeUndefined();
-        });
-    });
-
-    it('captures body when enabled', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => ({ ...baseOpts, captureRequestBody: true }));
-        provider.runWithContext({ body: { a: 1 }, headers: { 'content-type': 'application/json' } }, () => {
-            const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-            expect(attrs['http.request.body']).toBe('{"a":1}');
-        });
-    });
-
-    it('captures body with CONTENT-TYPE header casing', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => ({ ...baseOpts, captureRequestBody: true }));
-        provider.runWithContext({ body: { a: 1 }, headers: { 'CONTENT-TYPE': 'application/json' } }, () => {
-            const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-            expect(attrs['http.request.body']).toBe('{"a":1}');
-        });
-    });
-
-    it('captures body with Content-type header casing', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => ({ ...baseOpts, captureRequestBody: true }));
-        provider.runWithContext(
-            { body: '{"a":1}', headers: { 'Content-type': 'application/json; charset=utf-8' } },
-            () => {
-                const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-                expect(attrs['http.request.body']).toBe('{"a":1}');
-            },
-        );
-    });
-
-    it('captures body when content-type is an array value (uses first element)', () => {
-        const provider = new AsyncLocalStorageScopeProvider();
-        const collect = makeNodeContextCollector(provider, () => ({ ...baseOpts, captureRequestBody: true }));
-        provider.runWithContext({ body: { a: 1 }, headers: { 'content-type': ['application/json'] as any } }, () => {
-            const attrs = collect({ urlDenylist: DEFAULT_URL_DENYLIST } as any);
-            expect(attrs['http.request.body']).toBe('{"a":1}');
-        });
-    });
-});

package/tests/nodeExports.test.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { NodeScope } from '../src';
-
-describe('public exports from @flareapp/node', () => {
-    it('exports NodeScope as a class', () => {
-        expect(typeof NodeScope).toBe('function');
-        const s = new NodeScope();
-        expect(s).toBeDefined();
-    });
-});

package/tests/nodeScope.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { NodeScope } from '../src/scope/NodeScope';
-
-describe('NodeScope', () => {
-    it('starts with empty request and null user', () => {
-        const scope = new NodeScope();
-        expect(scope.request).toEqual({});
-        expect(scope.user).toBeNull();
-    });
-
-    it('inherits core Scope behavior (glows, attributes, entryPoint)', () => {
-        const scope = new NodeScope();
-        scope.setAttribute('k', 'v');
-        scope.addGlow({ name: 'g', messageLevel: 'info', metaData: {}, time: 0, microtime: 0 }, 10);
-        expect(scope.pendingAttributes).toEqual({ k: 'v' });
-        expect(scope.glows.length).toBe(1);
-    });
-});

package/tests/processAttributes.test.ts

@@ -1,15 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { collectProcessAttributes } from '../src/context/process';
-
-describe('collectProcessAttributes', () => {
-    it('includes runtime + host attributes', () => {
-        const attrs = collectProcessAttributes();
-        expect(attrs['process.runtime.name']).toBe('nodejs');
-        expect(attrs['process.runtime.version']).toBe(process.version);
-        expect(typeof attrs['process.pid']).toBe('number');
-        expect(typeof attrs['process.uptime']).toBe('number');
-        expect(typeof attrs['host.name']).toBe('string');
-        expect(typeof attrs['os.type']).toBe('string');
-    });
-});

package/tests/processHandlers.test.ts

@@ -1,47 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { ProcessHandlerManager } from '../src/process/handlers';
-
-describe('ProcessHandlerManager', () => {
-    let manager: ProcessHandlerManager;
-
-    afterEach(() => {
-        manager?.detach();
-    });
-
-    it('attaches no listeners when modes are off', () => {
-        const before = process.listeners('uncaughtException').length;
-        const beforeR = process.listeners('unhandledRejection').length;
-        manager = new ProcessHandlerManager({
-            onUncaught: vi.fn(),
-            onRejection: vi.fn(),
-        });
-        manager.reconcile({ uncaughtExceptionMode: 'off', unhandledRejectionMode: 'off' });
-        expect(process.listeners('uncaughtException').length).toBe(before);
-        expect(process.listeners('unhandledRejection').length).toBe(beforeR);
-    });
-
-    it('attaches handlers when modes are report or report-and-exit', () => {
-        const before = process.listeners('uncaughtException').length;
-        manager = new ProcessHandlerManager({ onUncaught: vi.fn(), onRejection: vi.fn() });
-        manager.reconcile({ uncaughtExceptionMode: 'report', unhandledRejectionMode: 'report' });
-        expect(process.listeners('uncaughtException').length).toBe(before + 1);
-    });
-
-    it('detaches when mode flips back to off', () => {
-        const before = process.listeners('uncaughtException').length;
-        manager = new ProcessHandlerManager({ onUncaught: vi.fn(), onRejection: vi.fn() });
-        manager.reconcile({ uncaughtExceptionMode: 'report', unhandledRejectionMode: 'off' });
-        expect(process.listeners('uncaughtException').length).toBe(before + 1);
-        manager.reconcile({ uncaughtExceptionMode: 'off', unhandledRejectionMode: 'off' });
-        expect(process.listeners('uncaughtException').length).toBe(before);
-    });
-
-    it('is idempotent — does not attach twice on repeated reconcile', () => {
-        const before = process.listeners('uncaughtException').length;
-        manager = new ProcessHandlerManager({ onUncaught: vi.fn(), onRejection: vi.fn() });
-        manager.reconcile({ uncaughtExceptionMode: 'report', unhandledRejectionMode: 'off' });
-        manager.reconcile({ uncaughtExceptionMode: 'report', unhandledRejectionMode: 'off' });
-        expect(process.listeners('uncaughtException').length).toBe(before + 1);
-    });
-});