@flareapp/node 0.1.0

package/tests/body.test.ts

@@ -0,0 +1,129 @@
+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('{}');
+    });
+});

package/tests/diskFileReader.test.ts

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,19 @@
+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);
+    });
+});