@smoothbricks/lmao 0.1.0

package/dist/lib/testing/vitest-harness.js

@@ -0,0 +1,486 @@
+/// <reference types="node" />
+/**
+ * vitest integration for LMAO trace-testing.
+ *
+ * Same architecture as bun-harness: one root trace per test run,
+ * each it() creates a child span, describe path written to `describe` schema column.
+ *
+ * Supports lifecycle tracer outputs (SQLite, stdio, or both via CompositeTracer).
+ *
+ * @example
+ * ```typescript
+ * // vitest.config.ts
+ * export default defineConfig({
+ *   test: { setupFiles: ['./test-setup.ts'] },
+ * });
+ *
+ * // test-setup.ts
+ * import { initTraceTestRun } from '@smoothbricks/lmao/testing/vitest';
+ * initTraceTestRun(myOpContext, { sqlite: { dbPath: '.trace-results.db' } });
+ *
+ * // my-test.test.ts
+ * import { describe, it, expect, useTestSpan } from '@smoothbricks/lmao/testing/vitest';
+ * ```
+ *
+ * @module testing/vitest
+ */
+import { afterAll as _afterAll, afterEach as _afterEach, beforeAll as _beforeAll, beforeEach as _beforeEach, describe as _describe, expect as _expect, it as _it, } from 'vitest';
+import { JsBufferStrategy } from '../JsBufferStrategy.js';
+import { S } from '../schema/builder.js';
+import { isSpanContext } from '../spanContext.js';
+import { createTraceRoot } from '../traceRoot.universal.js';
+import { Tracer } from '../tracer.js';
+import { CompositeTracer } from '../tracers/CompositeTracer.js';
+import { SQLiteAsyncTracer, SQLiteTracer } from '../tracers/SQLiteTracer.js';
+import { StdioTracer } from '../tracers/StdioTracer.js';
+import { TestTracer } from '../tracers/TestTracer.js';
+/** vitest expect() errors start with 'expect(received).' — distinguishes assertion failures from other throws */
+function isExpectError(error) {
+    return error instanceof Error && error.message.startsWith('expect(');
+}
+function readGlobalValue(key) {
+    return Reflect.get(globalThis, key);
+}
+function readProcessEnv(name) {
+    const processValue = Reflect.get(globalThis, 'process');
+    if (typeof processValue !== 'object' || processValue === null) {
+        return undefined;
+    }
+    const env = Reflect.get(processValue, 'env');
+    if (typeof env !== 'object' || env === null) {
+        return undefined;
+    }
+    const value = Reflect.get(env, name);
+    return typeof value === 'string' ? value : undefined;
+}
+function isVitestHarnessDebugEnabled() {
+    const globalDebug = readGlobalValue('__LMAO_VITEST_DEBUG__');
+    if (globalDebug === true) {
+        return true;
+    }
+    const injectedDebug = readGlobalValue('__LMAO_VITEST_DEBUG_ENV__');
+    if (injectedDebug === '1' || injectedDebug === 'true') {
+        return true;
+    }
+    const envDebug = readProcessEnv('LMAO_VITEST_DEBUG');
+    return envDebug === '1' || envDebug === 'true';
+}
+function vitestHarnessDebug(message, data) {
+    if (!isVitestHarnessDebugEnabled()) {
+        return;
+    }
+    if (data === undefined) {
+        console.error(`[lmao/vitest-harness] ${message}`);
+        return;
+    }
+    console.error(`[lmao/vitest-harness] ${message}`, data);
+}
+function isAsyncLocalStorageCtor(value) {
+    return typeof value === 'function';
+}
+function writeDescribeTag(tag, describePath) {
+    if (!describePath || typeof tag !== 'object' || tag === null) {
+        return;
+    }
+    const describeWriter = Reflect.get(tag, 'describe');
+    if (typeof describeWriter === 'function') {
+        describeWriter.call(tag, describePath);
+        return;
+    }
+    const batchWriter = Reflect.get(tag, 'with');
+    if (typeof batchWriter === 'function') {
+        batchWriter.call(tag, { describe: describePath });
+    }
+}
+function isTruthyEnvFlag(value) {
+    return value === true || value === '1' || value === 'true';
+}
+function isVerboseTraceEnabled(explicitVerbose) {
+    if (explicitVerbose !== undefined) {
+        return explicitVerbose;
+    }
+    const globalVerbose = readGlobalValue('__LMAO_TEST_TRACE_VERBOSE__');
+    if (isTruthyEnvFlag(globalVerbose)) {
+        return true;
+    }
+    const injectedVerbose = readGlobalValue('__LMAO_TEST_TRACE_VERBOSE_ENV__');
+    if (isTruthyEnvFlag(injectedVerbose)) {
+        return true;
+    }
+    return isTruthyEnvFlag(readProcessEnv('LMAO_TEST_TRACE_VERBOSE'));
+}
+class FallbackSpanContextStore {
+    current;
+    run(ctx, fn) {
+        const prev = this.current;
+        this.current = ctx;
+        try {
+            return fn();
+        }
+        finally {
+            this.current = prev;
+        }
+    }
+    getStore() {
+        return this.current;
+    }
+}
+function tryCreateAsyncLocalStorageStore() {
+    const maybeCtor = Reflect.get(globalThis, 'AsyncLocalStorage');
+    if (!isAsyncLocalStorageCtor(maybeCtor)) {
+        return null;
+    }
+    const storage = new maybeCtor();
+    return {
+        run(ctx, fn) {
+            return storage.run(ctx, fn);
+        },
+        getStore() {
+            return storage.getStore();
+        },
+    };
+}
+function createDefaultSpanContextStore() {
+    const store = tryCreateAsyncLocalStorageStore();
+    if (store) {
+        vitestHarnessDebug('using AsyncLocalStorage span store');
+        return store;
+    }
+    // Workers (e.g. Cloudflare Vitest pool) do not expose node:async_hooks.
+    // Fallback is safe for awaited test bodies, but detached async work will not
+    // retain the context automatically.
+    vitestHarnessDebug('using fallback span store');
+    return new FallbackSpanContextStore();
+}
+function createRootTracer({ binding, sqlite, verbose, }) {
+    const tracerOptions = {
+        bufferStrategy: new JsBufferStrategy(),
+        createTraceRoot,
+    };
+    let sqliteTracer = null;
+    if (sqlite?.createAsyncDatabase) {
+        const dbPath = sqlite.dbPath ?? '.trace-results.db';
+        sqliteTracer = new SQLiteAsyncTracer(binding, {
+            ...tracerOptions,
+            db: sqlite.createAsyncDatabase(dbPath),
+        });
+    }
+    else if (sqlite?.createDatabase) {
+        const db = sqlite.createDatabase(sqlite.dbPath ?? '.trace-results.db');
+        sqliteTracer = new SQLiteTracer(binding, {
+            ...tracerOptions,
+            db,
+        });
+    }
+    if (sqliteTracer) {
+        if (verbose) {
+            const stdioTracer = new StdioTracer(binding, {
+                ...tracerOptions,
+            });
+            return new CompositeTracer(binding, {
+                ...tracerOptions,
+                delegates: [stdioTracer, sqliteTracer],
+            });
+        }
+        return sqliteTracer;
+    }
+    if (verbose) {
+        return new StdioTracer(binding, {
+            ...tracerOptions,
+        });
+    }
+    return new TestTracer(binding, {
+        ...tracerOptions,
+    });
+}
+async function closeTracer(tracer) {
+    const close = Reflect.get(tracer, 'close');
+    if (typeof close === 'function') {
+        await close.call(tracer);
+    }
+}
+let _activeSuiteTracer = null;
+function createActiveVitestTestTracer(tracer) {
+    return {
+        initTraceTestRun: (options) => tracer.initTraceTestRun(options),
+        useTestSpan: () => tracer.useTestSpan(),
+        getTracer: () => tracer.getTracer(),
+        createVitestMock: (vitestModule) => tracer.createVitestMock(vitestModule),
+        describe: (name, fn) => tracer.describe(name, fn),
+        it: (name, fn) => tracer.it(name, fn),
+    };
+}
+export function installVitestTestTracing(tracer, options) {
+    tracer.initTraceTestRun(options);
+    _activeSuiteTracer = createActiveVitestTestTracer(tracer);
+}
+export function makeVitestTestSuiteTracer(config, options) {
+    const useTestTracer = makeVitestTestTracer(config);
+    return {
+        useTestTracer,
+        useTestSpan: () => useTestTracer.useTestSpan(),
+        setupVitestTestSuiteTracing: () => installVitestTestTracing(useTestTracer, options),
+    };
+}
+export function makeVitestTestTracer(config) {
+    const { binding } = config;
+    const spanStore = config.createSpanContextStore?.() ?? createDefaultSpanContextStore();
+    vitestHarnessDebug('created vitest test tracer instance');
+    let initialized = false;
+    let tracer = null;
+    let verboseTrace = false;
+    let rootCtx = null;
+    let resolveTestRun = null;
+    let rootTracePromise = null;
+    const standaloneDescribeStack = [];
+    function getRootCtx() {
+        if (!rootCtx) {
+            throw new Error('Call initTraceTestRun() in setupFiles before tests');
+        }
+        return rootCtx;
+    }
+    function createExtendedBinding() {
+        const extendedSchema = binding.logBinding.logSchema.extend({ describe: S.category() });
+        const extendedBinding = {
+            ...binding,
+            logBinding: { ...binding.logBinding, logSchema: extendedSchema },
+        };
+        return extendedBinding;
+    }
+    function initTraceTestRun(options) {
+        if (initialized) {
+            throw new Error('initTraceTestRun() already called for this vitest tracer instance');
+        }
+        initialized = true;
+        verboseTrace = isVerboseTraceEnabled(options?.verbose);
+        vitestHarnessDebug('initTraceTestRun start', {
+            sqliteConfigured: options?.sqlite?.createDatabase !== undefined || options?.sqlite?.createAsyncDatabase !== undefined,
+            verboseTrace,
+        });
+        // Extend user's schema with `describe` column for test grouping.
+        const extendedBinding = createExtendedBinding();
+        tracer = createRootTracer({
+            binding: extendedBinding,
+            sqlite: options?.sqlite,
+            verbose: verboseTrace,
+        });
+        vitestHarnessDebug('created root tracer for vitest harness');
+        const activeTracer = tracer;
+        rootTracePromise = activeTracer.trace('test-run', (ctx) => {
+            rootCtx = ctx;
+            vitestHarnessDebug('root test-run span started', { trace_id: ctx.buffer.trace_id });
+            return new Promise((resolve) => {
+                resolveTestRun = resolve;
+            });
+        });
+        vitestHarnessDebug('root trace promise created');
+        _afterAll(async () => {
+            vitestHarnessDebug('afterAll hook start');
+            if (resolveTestRun) {
+                resolveTestRun();
+                resolveTestRun = null;
+                vitestHarnessDebug('resolved root test-run promise');
+            }
+            if (rootTracePromise) {
+                await rootTracePromise;
+                rootTracePromise = null;
+                vitestHarnessDebug('awaited root trace promise');
+            }
+            if (tracer && rootCtx) {
+                try {
+                    vitestHarnessDebug('flushing tracer');
+                    await tracer.flush();
+                    if (options?.sqlite) {
+                        const traceId = rootCtx.buffer.trace_id;
+                        const dbPath = options.sqlite.dbPath ?? '.trace-results.db';
+                        console.log(`\n[trace] trace_id: ${traceId} → ${dbPath}`);
+                    }
+                }
+                catch (error) {
+                    console.error('[lmao/testing] SQLite flush error:', error);
+                }
+                finally {
+                    await closeTracer(tracer);
+                }
+            }
+            vitestHarnessDebug('afterAll hook complete');
+        });
+    }
+    function useTestSpan() {
+        const ctx = spanStore.getStore();
+        if (!ctx) {
+            throw new Error('useTestSpan() called outside of a traced it()');
+        }
+        return ctx;
+    }
+    function getTracer() {
+        if (!tracer) {
+            throw new Error('Call initTraceTestRun() in setupFiles before tests');
+        }
+        return tracer;
+    }
+    function createVitestMock(vitestModule) {
+        vitestHarnessDebug('createVitestMock called');
+        const currentRootCtx = getRootCtx();
+        const origIt = vitestModule.it;
+        const origDescribe = vitestModule.describe;
+        const describeStack = [];
+        function wrappedDescribe(name, fn) {
+            return origDescribe(name, () => {
+                describeStack.push(name);
+                try {
+                    fn();
+                }
+                finally {
+                    describeStack.pop();
+                }
+            });
+        }
+        Object.assign(wrappedDescribe, {
+            skip: origDescribe.skip,
+            only: origDescribe.only,
+            todo: origDescribe.todo,
+            each: origDescribe.each,
+            skipIf: origDescribe.skipIf.bind(origDescribe),
+        });
+        function wrappedIt(name, fn) {
+            const describePath = describeStack.length > 0 ? describeStack.join(' > ') : null;
+            return origIt(name, () => currentRootCtx.span(name, async (ctx) => {
+                writeDescribeTag(ctx.tag, describePath);
+                try {
+                    await spanStore.run(ctx, fn);
+                    return ctx.ok(undefined);
+                }
+                catch (error) {
+                    if (isExpectError(error)) {
+                        return ctx.err(error);
+                    }
+                    throw error;
+                }
+            }));
+        }
+        Object.assign(wrappedIt, {
+            skip: origIt.skip,
+            only: origIt.only,
+            todo: origIt.todo,
+            each: origIt.each,
+            skipIf: origIt.skipIf.bind(origIt),
+        });
+        return {
+            ...vitestModule,
+            describe: wrappedDescribe,
+            it: wrappedIt,
+            test: wrappedIt,
+        };
+    }
+    function describe(name, fn) {
+        return _describe(name, () => {
+            standaloneDescribeStack.push(name);
+            try {
+                fn();
+            }
+            finally {
+                standaloneDescribeStack.pop();
+            }
+        });
+    }
+    function it(name, fn) {
+        const describePath = standaloneDescribeStack.length > 0 ? standaloneDescribeStack.join(' > ') : null;
+        _it(name, () => {
+            const currentRootCtx = getRootCtx();
+            return currentRootCtx.span(name, async (ctx) => {
+                writeDescribeTag(ctx.tag, describePath);
+                try {
+                    await spanStore.run(ctx, fn);
+                    return ctx.ok(undefined);
+                }
+                catch (error) {
+                    if (isExpectError(error)) {
+                        return ctx.err(error);
+                    }
+                    throw error;
+                }
+            });
+        });
+    }
+    return {
+        initTraceTestRun,
+        useTestSpan,
+        getTracer,
+        createVitestMock,
+        describe,
+        it,
+    };
+}
+function requireActiveSuiteTracer(message) {
+    if (!_activeSuiteTracer) {
+        throw new Error(message);
+    }
+    return _activeSuiteTracer;
+}
+/** Initialize the root tracer for the entire vitest run. Call once in setupFiles. */
+export function initTraceTestRun(opContext, options) {
+    installVitestTestTracing(makeVitestTestTracer({ binding: opContext }), options);
+}
+/** Get the current span context from AsyncLocalStorage (inside an it() block) */
+export function useTestSpan() {
+    const ctx = requireActiveSuiteTracer('Call initTraceTestRun() in setupFiles before tests').useTestSpan();
+    if (!isSpanContext(ctx)) {
+        throw new Error('Active suite tracer returned a non-span context');
+    }
+    return ctx;
+}
+/** Get the root tracer instance */
+export function getTracer() {
+    const tracer = requireActiveSuiteTracer('Call initTraceTestRun() in setupFiles before tests').getTracer();
+    if (!(tracer instanceof Tracer)) {
+        throw new Error('Active suite tracer returned a non-tracer');
+    }
+    return tracer;
+}
+/**
+ * Create a vitest mock replacement that wraps it()/test()/describe() with trace spans.
+ *
+ * Call this from a vitest setupFile via vi.mock:
+ * ```typescript
+ * vi.mock('vitest', async (importOriginal) => {
+ *   const [mod, { createVitestMock }] = await Promise.all([
+ *     importOriginal(),
+ *     import('@smoothbricks/lmao/testing/vitest'),
+ *   ]);
+ *   return createVitestMock(mod);
+ * });
+ * ```
+ *
+ * @param vitestModule - The original vitest namespace from importOriginal()
+ */
+export function createVitestMock(vitestModule) {
+    return requireActiveSuiteTracer('Call initTraceTestRun() before createVitestMock()').createVitestMock(vitestModule);
+}
+/**
+ * Wrapped describe — tracks describe nesting for the standalone export path.
+ * describe() callbacks run synchronously (just registering tests).
+ */
+const describeBase = (name, fn) => {
+    return requireActiveSuiteTracer('Call initTraceTestRun() in setupFiles before tests').describe(name, fn);
+};
+export const describe = Object.assign(describeBase, {
+    skip: (name, fn) => _describe.skip(name, fn),
+    only: (name, fn) => _describe.only(name, fn),
+    todo: (name, fn) => _describe.todo(name, fn),
+    each: (...args) => Reflect.apply(_describe.each, _describe, args),
+    skipIf: (condition) => (condition ? _describe.skip : describe),
+});
+/** Wrapped it — creates a child span of the root trace for the test case */
+const itBase = (name, fn) => {
+    return requireActiveSuiteTracer('Call initTraceTestRun() in setupFiles before tests').it(name, fn);
+};
+export const it = Object.assign(itBase, {
+    skip: (name, fn) => _it.skip(name, fn),
+    only: (name, fn) => _it.only(name, fn),
+    todo: (name, fn) => _it.todo(name, fn),
+    each: (...args) => Reflect.apply(_it.each, _it, args),
+    skipIf: (condition) => (condition ? _it.skip : it),
+});
+// Re-export everything else unchanged
+export { _afterAll as afterAll, _afterEach as afterEach, _beforeAll as beforeAll, _beforeEach as beforeEach, _expect as expect, };

package/dist/lib/threadId.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Thread ID - Process-level unique identifier for distributed span identification
+ *
+ * Each worker/process gets a unique 64-bit random ID that remains constant
+ * for the lifetime of the process. Combined with a local incrementing counter,
+ * this provides globally unique span IDs without coordination.
+ *
+ * The thread ID is stored as raw bytes (Uint8Array) to enable zero-copy
+ * writes to SpanBuffer identity sections.
+ *
+ * ## Module-level = Per-Process/Worker Singleton
+ *
+ * ES modules are instantiated once per JavaScript realm:
+ * - **Node.js main process**: One thread ID per process
+ * - **Node.js worker_threads**: Each Worker gets its own module instance → own thread ID
+ * - **Browser main thread**: One thread ID
+ * - **Web Workers**: Each Worker gets its own module instance → own thread ID
+ *
+ * This is exactly what we want: each "thread of execution" automatically gets
+ * a unique ID without any explicit thread-local storage API.
+ *
+ * @module threadId
+ */
+/** Thread ID size in bytes */
+export declare const THREAD_ID_BYTES = 8;
+/**
+ * Copy the process thread ID bytes to a destination buffer.
+ * This is the primary hot-path API for SpanBuffer construction.
+ *
+ * @param dest - Destination Uint8Array
+ * @param offset - Byte offset in destination
+ */
+export declare function copyThreadIdTo(dest: Uint8Array, offset: number): void;
+/**
+ * Get the process thread ID as a BigInt.
+ * Use copyThreadIdTo() for hot-path writes; this is for Arrow conversion.
+ *
+ * @returns 64-bit thread ID as BigInt
+ */
+export declare function getThreadId(): bigint;
+/**
+ * Write the process thread ID to a BigUint64Array at the given index.
+ * Avoids BigInt conversion by writing bytes directly to the underlying buffer.
+ *
+ * @param dest - Destination BigUint64Array
+ * @param index - Element index (not byte offset)
+ */
+export declare function writeThreadIdToUint64Array(dest: BigUint64Array, index: number): void;
+/**
+ * Reset thread ID for testing purposes only.
+ *
+ * **WARNING**: Only use in tests! Resetting in production would break
+ * span ID uniqueness guarantees.
+ *
+ * @internal
+ */
+export declare function _resetThreadId(): void;
+//# sourceMappingURL=threadId.d.ts.map

package/dist/lib/threadId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threadId.d.ts","sourceRoot":"","sources":["../../src/lib/threadId.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,8BAA8B;AAC9B,eAAO,MAAM,eAAe,IAAI,CAAC;AAwCjC;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAMrE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAmBpC;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAOpF;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAGrC"}

package/dist/lib/threadId.js

@@ -0,0 +1,123 @@
+/**
+ * Thread ID - Process-level unique identifier for distributed span identification
+ *
+ * Each worker/process gets a unique 64-bit random ID that remains constant
+ * for the lifetime of the process. Combined with a local incrementing counter,
+ * this provides globally unique span IDs without coordination.
+ *
+ * The thread ID is stored as raw bytes (Uint8Array) to enable zero-copy
+ * writes to SpanBuffer identity sections.
+ *
+ * ## Module-level = Per-Process/Worker Singleton
+ *
+ * ES modules are instantiated once per JavaScript realm:
+ * - **Node.js main process**: One thread ID per process
+ * - **Node.js worker_threads**: Each Worker gets its own module instance → own thread ID
+ * - **Browser main thread**: One thread ID
+ * - **Web Workers**: Each Worker gets its own module instance → own thread ID
+ *
+ * This is exactly what we want: each "thread of execution" automatically gets
+ * a unique ID without any explicit thread-local storage API.
+ *
+ * @module threadId
+ */
+/** Thread ID size in bytes */
+export const THREAD_ID_BYTES = 8;
+/** Process-level thread ID bytes (lazily initialized) */
+let threadIdBytes = null;
+/** Cached BigInt representation (lazily computed) */
+let threadIdBigInt = null;
+/**
+ * Ensure thread ID is initialized.
+ * Called lazily on first access.
+ */
+function ensureInitialized() {
+    if (threadIdBytes !== null)
+        return;
+    threadIdBytes = new Uint8Array(THREAD_ID_BYTES);
+    // Use Web Crypto API - available in browsers, Node 19+, Deno, Bun, Workers
+    if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {
+        crypto.getRandomValues(threadIdBytes);
+        return;
+    }
+    // For Node.js < 19, try to use node:crypto
+    try {
+        const nodeCrypto = require('node:crypto');
+        if (nodeCrypto && typeof nodeCrypto.randomFillSync === 'function') {
+            nodeCrypto.randomFillSync(threadIdBytes);
+            return;
+        }
+    }
+    catch {
+        // node:crypto not available
+    }
+    throw new Error('crypto.getRandomValues is not available. ' +
+        'For React Native, install and import "react-native-get-random-values" before using this library.');
+}
+/**
+ * Copy the process thread ID bytes to a destination buffer.
+ * This is the primary hot-path API for SpanBuffer construction.
+ *
+ * @param dest - Destination Uint8Array
+ * @param offset - Byte offset in destination
+ */
+export function copyThreadIdTo(dest, offset) {
+    ensureInitialized();
+    if (!threadIdBytes) {
+        throw new Error('ThreadId bytes not initialized');
+    }
+    dest.set(threadIdBytes, offset);
+}
+/**
+ * Get the process thread ID as a BigInt.
+ * Use copyThreadIdTo() for hot-path writes; this is for Arrow conversion.
+ *
+ * @returns 64-bit thread ID as BigInt
+ */
+export function getThreadId() {
+    ensureInitialized();
+    if (threadIdBigInt === null) {
+        if (!threadIdBytes) {
+            throw new Error('ThreadId bytes not initialized');
+        }
+        const b = threadIdBytes;
+        // Little-endian conversion to match identity byte layout
+        threadIdBigInt =
+            BigInt(b[0]) |
+                (BigInt(b[1]) << 8n) |
+                (BigInt(b[2]) << 16n) |
+                (BigInt(b[3]) << 24n) |
+                (BigInt(b[4]) << 32n) |
+                (BigInt(b[5]) << 40n) |
+                (BigInt(b[6]) << 48n) |
+                (BigInt(b[7]) << 56n);
+    }
+    return threadIdBigInt;
+}
+/**
+ * Write the process thread ID to a BigUint64Array at the given index.
+ * Avoids BigInt conversion by writing bytes directly to the underlying buffer.
+ *
+ * @param dest - Destination BigUint64Array
+ * @param index - Element index (not byte offset)
+ */
+export function writeThreadIdToUint64Array(dest, index) {
+    ensureInitialized();
+    if (!threadIdBytes) {
+        throw new Error('ThreadId bytes not initialized');
+    }
+    const byteView = new Uint8Array(dest.buffer, dest.byteOffset + index * 8, 8);
+    byteView.set(threadIdBytes);
+}
+/**
+ * Reset thread ID for testing purposes only.
+ *
+ * **WARNING**: Only use in tests! Resetting in production would break
+ * span ID uniqueness guarantees.
+ *
+ * @internal
+ */
+export function _resetThreadId() {
+    threadIdBytes = null;
+    threadIdBigInt = null;
+}