@openclaw/diagnostics-otel 2026.7.2-beta.7 → 2026.7.34

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/wasi.d.ts

@@ -0,0 +1,131 @@
+declare module "node:wasi" {
+    interface WASIOptions {
+        /**
+         * An array of strings that the WebAssembly application will
+         * see as command line arguments. The first argument is the virtual path to the
+         * WASI command itself.
+         * @default []
+         */
+        args?: readonly string[] | undefined;
+        /**
+         * An object similar to `process.env` that the WebAssembly
+         * application will see as its environment.
+         * @default {}
+         */
+        env?: object | undefined;
+        /**
+         * This object represents the WebAssembly application's
+         * sandbox directory structure. The string keys of `preopens` are treated as
+         * directories within the sandbox. The corresponding values in `preopens` are
+         * the real paths to those directories on the host machine.
+         */
+        preopens?: NodeJS.Dict<string> | undefined;
+        /**
+         * By default, when WASI applications call `__wasi_proc_exit()`
+         * `wasi.start()` will return with the exit code specified rather than terminatng the process.
+         * Setting this option to `false` will cause the Node.js process to exit with
+         * the specified exit code instead.
+         * @default true
+         */
+        returnOnExit?: boolean | undefined;
+        /**
+         * The file descriptor used as standard input in the WebAssembly application.
+         * @default 0
+         */
+        stdin?: number | undefined;
+        /**
+         * The file descriptor used as standard output in the WebAssembly application.
+         * @default 1
+         */
+        stdout?: number | undefined;
+        /**
+         * The file descriptor used as standard error in the WebAssembly application.
+         * @default 2
+         */
+        stderr?: number | undefined;
+        /**
+         * The version of WASI requested.
+         * Currently the only supported versions are `'unstable'` and `'preview1'`. This option is mandatory.
+         * @since v19.8.0
+         */
+        version: "unstable" | "preview1";
+    }
+    interface FinalizeBindingsOptions {
+        /**
+         * @default instance.exports.memory
+         */
+        memory?: object | undefined;
+    }
+    /**
+     * The `WASI` class provides the WASI system call API and additional convenience
+     * methods for working with WASI-based applications. Each `WASI` instance
+     * represents a distinct environment.
+     * @since v13.3.0, v12.16.0
+     */
+    class WASI {
+        constructor(options?: WASIOptions);
+        /**
+         * Return an import object that can be passed to `WebAssembly.instantiate()` if no other WASM imports are needed beyond those provided by WASI.
+         *
+         * If version `unstable` was passed into the constructor it will return:
+         *
+         * ```js
+         * { wasi_unstable: wasi.wasiImport }
+         * ```
+         *
+         * If version `preview1` was passed into the constructor or no version was specified it will return:
+         *
+         * ```js
+         * { wasi_snapshot_preview1: wasi.wasiImport }
+         * ```
+         * @since v19.8.0
+         */
+        getImportObject(): object;
+        /**
+         * Attempt to begin execution of `instance` as a WASI command by invoking its `_start()` export. If `instance` does not contain a `_start()` export, or if `instance` contains an `_initialize()`
+         * export, then an exception is thrown.
+         *
+         * `start()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named `memory`. If
+         * `instance` does not have a `memory` export an exception is thrown.
+         *
+         * If `start()` is called more than once, an exception is thrown.
+         * @since v13.3.0, v12.16.0
+         */
+        start(instance: object): number; // TODO: avoid DOM dependency until WASM moved to own lib.
+        /**
+         * Attempt to initialize `instance` as a WASI reactor by invoking its `_initialize()` export, if it is present. If `instance` contains a `_start()` export, then an exception is thrown.
+         *
+         * `initialize()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named `memory`.
+         * If `instance` does not have a `memory` export an exception is thrown.
+         *
+         * If `initialize()` is called more than once, an exception is thrown.
+         * @since v14.6.0, v12.19.0
+         */
+        initialize(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
+        /**
+         * Set up WASI host bindings to `instance` without calling `initialize()`
+         * or `start()`. This method is useful when the WASI module is instantiated in
+         * child threads for sharing the memory across threads.
+         *
+         * `finalizeBindings()` requires that either `instance` exports a
+         * [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named `memory` or user specify a
+         * [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) object in `options.memory`. If the `memory` is invalid
+         * an exception is thrown.
+         *
+         * `start()` and `initialize()` will call `finalizeBindings()` internally.
+         * If `finalizeBindings()` is called more than once, an exception is thrown.
+         * @since v24.4.0
+         */
+        finalizeBindings(instance: object, options?: FinalizeBindingsOptions): void;
+        /**
+         * `wasiImport` is an object that implements the WASI system call API. This object
+         * should be passed as the `wasi_snapshot_preview1` import during the instantiation
+         * of a [`WebAssembly.Instance`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance).
+         * @since v13.3.0, v12.16.0
+         */
+        readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
+    }
+}
+declare module "wasi" {
+    export * from "node:wasi";
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/abortcontroller.d.ts

@@ -0,0 +1,59 @@
+export {};
+
+import { InternalEventTargetEventProperties } from "node:events";
+
+type _AbortController = typeof globalThis extends { onmessage: any } ? {} : AbortController;
+interface AbortController {
+    readonly signal: AbortSignal;
+    abort(reason?: any): void;
+}
+
+interface AbortSignalEventMap {
+    "abort": Event;
+}
+
+type _AbortSignal = typeof globalThis extends { onmessage: any } ? {} : AbortSignal;
+interface AbortSignal extends EventTarget, InternalEventTargetEventProperties<AbortSignalEventMap> {
+    readonly aborted: boolean;
+    readonly reason: any;
+    throwIfAborted(): void;
+    addEventListener<K extends keyof AbortSignalEventMap>(
+        type: K,
+        listener: (ev: AbortSignalEventMap[K]) => void,
+        options?: AddEventListenerOptions | boolean,
+    ): void;
+    addEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: AddEventListenerOptions | boolean,
+    ): void;
+    removeEventListener<K extends keyof AbortSignalEventMap>(
+        type: K,
+        listener: (ev: AbortSignalEventMap[K]) => void,
+        options?: EventListenerOptions | boolean,
+    ): void;
+    removeEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: EventListenerOptions | boolean,
+    ): void;
+}
+
+declare global {
+    interface AbortController extends _AbortController {}
+    var AbortController: typeof globalThis extends { onmessage: any; AbortController: infer T } ? T
+        : {
+            prototype: AbortController;
+            new(): AbortController;
+        };
+
+    interface AbortSignal extends _AbortSignal {}
+    var AbortSignal: typeof globalThis extends { onmessage: any; AbortSignal: infer T } ? T
+        : {
+            prototype: AbortSignal;
+            new(): AbortSignal;
+            abort(reason?: any): AbortSignal;
+            any(signals: AbortSignal[]): AbortSignal;
+            timeout(milliseconds: number): AbortSignal;
+        };
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/blob.d.ts

@@ -0,0 +1,23 @@
+export {};
+
+import * as buffer from "node:buffer";
+
+type _Blob = typeof globalThis extends { onmessage: any } ? {} : buffer.Blob;
+type _BlobPropertyBag = typeof globalThis extends { onmessage: any } ? {} : buffer.BlobPropertyBag;
+type _File = typeof globalThis extends { onmessage: any } ? {} : buffer.File;
+type _FilePropertyBag = typeof globalThis extends { onmessage: any } ? {} : buffer.FilePropertyBag;
+
+declare global {
+    interface Blob extends _Blob {}
+    var Blob: typeof globalThis extends { onmessage: any; Blob: infer T } ? T : typeof buffer.Blob;
+
+    interface BlobPropertyBag extends _BlobPropertyBag {}
+
+    interface File extends _File {}
+    var File: typeof globalThis extends { onmessage: any; File: infer T } ? T : typeof buffer.File;
+
+    interface FilePropertyBag extends _FilePropertyBag {}
+
+    function atob(data: string): string;
+    function btoa(data: string): string;
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/console.d.ts

@@ -0,0 +1,9 @@
+export {};
+
+import * as console from "node:console";
+
+declare global {
+    interface Console extends console.Console {}
+
+    var console: Console;
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/crypto.d.ts

@@ -0,0 +1,39 @@
+export {};
+
+import { webcrypto } from "crypto";
+
+type _Crypto = typeof globalThis extends { onmessage: any } ? {} : webcrypto.Crypto;
+type _CryptoKey = typeof globalThis extends { onmessage: any } ? {} : webcrypto.CryptoKey;
+type _SubtleCrypto = typeof globalThis extends { onmessage: any } ? {} : webcrypto.SubtleCrypto;
+
+declare global {
+    interface Crypto extends _Crypto {}
+    var Crypto: typeof globalThis extends { onmessage: any; Crypto: infer T } ? T : {
+        prototype: webcrypto.Crypto;
+        new(): webcrypto.Crypto;
+    };
+
+    interface CryptoKey extends _CryptoKey {}
+    var CryptoKey: typeof globalThis extends { onmessage: any; CryptoKey: infer T } ? T : {
+        prototype: webcrypto.CryptoKey;
+        new(): webcrypto.CryptoKey;
+    };
+
+    interface SubtleCrypto extends _SubtleCrypto {}
+    var SubtleCrypto: typeof globalThis extends { onmessage: any; SubtleCrypto: infer T } ? T : {
+        prototype: webcrypto.SubtleCrypto;
+        new(): webcrypto.SubtleCrypto;
+        supports(
+            operation: string,
+            algorithm: webcrypto.AlgorithmIdentifier,
+            length?: number,
+        ): boolean;
+        supports(
+            operation: string,
+            algorithm: webcrypto.AlgorithmIdentifier,
+            additionalAlgorithm: webcrypto.AlgorithmIdentifier,
+        ): boolean;
+    };
+
+    var crypto: typeof globalThis extends { onmessage: any; crypto: infer T } ? T : webcrypto.Crypto;
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/domexception.d.ts

@@ -0,0 +1,83 @@
+export {};
+
+type _DOMException = typeof globalThis extends { onmessage: any } ? {} : DOMException;
+interface DOMException extends Error {
+    readonly code: number;
+    readonly message: string;
+    readonly name: string;
+    readonly INDEX_SIZE_ERR: 1;
+    readonly DOMSTRING_SIZE_ERR: 2;
+    readonly HIERARCHY_REQUEST_ERR: 3;
+    readonly WRONG_DOCUMENT_ERR: 4;
+    readonly INVALID_CHARACTER_ERR: 5;
+    readonly NO_DATA_ALLOWED_ERR: 6;
+    readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+    readonly NOT_FOUND_ERR: 8;
+    readonly NOT_SUPPORTED_ERR: 9;
+    readonly INUSE_ATTRIBUTE_ERR: 10;
+    readonly INVALID_STATE_ERR: 11;
+    readonly SYNTAX_ERR: 12;
+    readonly INVALID_MODIFICATION_ERR: 13;
+    readonly NAMESPACE_ERR: 14;
+    readonly INVALID_ACCESS_ERR: 15;
+    readonly VALIDATION_ERR: 16;
+    readonly TYPE_MISMATCH_ERR: 17;
+    readonly SECURITY_ERR: 18;
+    readonly NETWORK_ERR: 19;
+    readonly ABORT_ERR: 20;
+    readonly URL_MISMATCH_ERR: 21;
+    readonly QUOTA_EXCEEDED_ERR: 22;
+    readonly TIMEOUT_ERR: 23;
+    readonly INVALID_NODE_TYPE_ERR: 24;
+    readonly DATA_CLONE_ERR: 25;
+}
+
+declare global {
+    interface DOMException extends _DOMException {}
+    var DOMException: typeof globalThis extends { onmessage: any; DOMException: infer T } ? T
+        : {
+            prototype: DOMException;
+            new(message?: string, name?: string): DOMException;
+            new(message?: string, options?: { name?: string; cause?: unknown }): DOMException;
+            readonly INDEX_SIZE_ERR: 1;
+            readonly DOMSTRING_SIZE_ERR: 2;
+            readonly HIERARCHY_REQUEST_ERR: 3;
+            readonly WRONG_DOCUMENT_ERR: 4;
+            readonly INVALID_CHARACTER_ERR: 5;
+            readonly NO_DATA_ALLOWED_ERR: 6;
+            readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+            readonly NOT_FOUND_ERR: 8;
+            readonly NOT_SUPPORTED_ERR: 9;
+            readonly INUSE_ATTRIBUTE_ERR: 10;
+            readonly INVALID_STATE_ERR: 11;
+            readonly SYNTAX_ERR: 12;
+            readonly INVALID_MODIFICATION_ERR: 13;
+            readonly NAMESPACE_ERR: 14;
+            readonly INVALID_ACCESS_ERR: 15;
+            readonly VALIDATION_ERR: 16;
+            readonly TYPE_MISMATCH_ERR: 17;
+            readonly SECURITY_ERR: 18;
+            readonly NETWORK_ERR: 19;
+            readonly ABORT_ERR: 20;
+            readonly URL_MISMATCH_ERR: 21;
+            readonly QUOTA_EXCEEDED_ERR: 22;
+            readonly TIMEOUT_ERR: 23;
+            readonly INVALID_NODE_TYPE_ERR: 24;
+            readonly DATA_CLONE_ERR: 25;
+        };
+
+    // Not conditional, as this is not yet exposed by the DOM lib generator.
+    interface QuotaExceededError extends DOMException {
+        readonly quota: number | null;
+        readonly requested: number | null;
+    }
+    var QuotaExceededError: {
+        prototype: QuotaExceededError;
+        new(message?: string, options?: QuotaExceededErrorOptions): QuotaExceededError;
+    };
+
+    interface QuotaExceededErrorOptions {
+        quota?: number;
+        requested?: number;
+    }
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/encoding.d.ts

@@ -0,0 +1,11 @@
+export {};
+
+import * as util from "node:util";
+
+declare global {
+    interface TextDecoder extends util.TextDecoder {}
+    var TextDecoder: typeof globalThis extends { onmessage: any; TextDecoder: infer T } ? T : typeof util.TextDecoder;
+
+    interface TextEncoder extends util.TextEncoder {}
+    var TextEncoder: typeof globalThis extends { onmessage: any; TextEncoder: infer T } ? T : typeof util.TextEncoder;
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/events.d.ts

@@ -0,0 +1,106 @@
+export {};
+
+type _AddEventListenerOptions = typeof globalThis extends { onmessage: any } ? {} : AddEventListenerOptions;
+interface AddEventListenerOptions extends EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+}
+
+type _CustomEvent<T = any> = typeof globalThis extends { onmessage: any } ? {} : CustomEvent<T>;
+interface CustomEvent<T = any> extends Event {
+    readonly detail: T;
+}
+
+interface CustomEventInit<T = any> extends EventInit {
+    detail?: T;
+}
+
+type _Event = typeof globalThis extends { onmessage: any } ? {} : Event;
+interface Event {
+    readonly bubbles: boolean;
+    cancelBubble: boolean;
+    readonly cancelable: boolean;
+    readonly composed: boolean;
+    readonly currentTarget: EventTarget | null;
+    readonly defaultPrevented: boolean;
+    readonly eventPhase: 0 | 2;
+    readonly isTrusted: boolean;
+    returnValue: boolean;
+    readonly srcElement: EventTarget | null;
+    readonly target: EventTarget | null;
+    readonly timeStamp: number;
+    readonly type: string;
+    composedPath(): [EventTarget?];
+    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+    preventDefault(): void;
+    stopImmediatePropagation(): void;
+    stopPropagation(): void;
+}
+
+interface EventInit {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+
+type _EventListener = typeof globalThis extends { onmessage: any } ? {} : EventListener;
+interface EventListener {
+    (evt: Event): void;
+}
+
+type _EventListenerObject = typeof globalThis extends { onmessage: any } ? {} : EventListenerObject;
+interface EventListenerObject {
+    handleEvent(object: Event): void;
+}
+
+type _EventListenerOptions = typeof globalThis extends { onmessage: any } ? {} : EventListenerOptions;
+interface EventListenerOptions {
+    capture?: boolean;
+}
+
+type _EventTarget = typeof globalThis extends { onmessage: any } ? {} : EventTarget;
+interface EventTarget {
+    addEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: AddEventListenerOptions | boolean,
+    ): void;
+    dispatchEvent(event: Event): boolean;
+    removeEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: EventListenerOptions | boolean,
+    ): void;
+}
+
+declare global {
+    interface AddEventListenerOptions extends _AddEventListenerOptions {}
+
+    interface CustomEvent<T = any> extends _CustomEvent<T> {}
+    var CustomEvent: typeof globalThis extends { onmessage: any; CustomEvent: infer T } ? T
+        : {
+            prototype: CustomEvent;
+            new<T>(type: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
+        };
+
+    interface Event extends _Event {}
+    var Event: typeof globalThis extends { onmessage: any; Event: infer T } ? T
+        : {
+            prototype: Event;
+            new(type: string, eventInitDict?: EventInit): Event;
+        };
+
+    interface EventListener extends _EventListener {}
+
+    interface EventListenerObject extends _EventListenerObject {}
+
+    interface EventListenerOptions extends _EventListenerOptions {}
+
+    interface EventTarget extends _EventTarget {}
+    var EventTarget: typeof globalThis extends { onmessage: any; EventTarget: infer T } ? T
+        : {
+            prototype: EventTarget;
+            new(): EventTarget;
+        };
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/fetch.d.ts

@@ -0,0 +1,69 @@
+export {};
+
+import * as undici from "undici-types";
+
+type _CloseEvent = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEvent;
+type _CloseEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEventInit;
+type _ErrorEvent = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEvent;
+type _ErrorEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEventInit;
+type _EventSource = typeof globalThis extends { onmessage: any } ? {} : undici.EventSource;
+type _EventSourceInit = typeof globalThis extends { onmessage: any } ? {} : undici.EventSourceInit;
+type _FormData = typeof globalThis extends { onmessage: any } ? {} : undici.FormData;
+type _Headers = typeof globalThis extends { onmessage: any } ? {} : undici.Headers;
+type _MessageEvent = typeof globalThis extends { onmessage: any } ? {} : undici.MessageEvent;
+type _MessageEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.MessageEventInit;
+type _Request = typeof globalThis extends { onmessage: any } ? {} : undici.Request;
+type _RequestInit = typeof globalThis extends { onmessage: any } ? {} : undici.RequestInit;
+type _Response = typeof globalThis extends { onmessage: any } ? {} : undici.Response;
+type _ResponseInit = typeof globalThis extends { onmessage: any } ? {} : undici.ResponseInit;
+type _WebSocket = typeof globalThis extends { onmessage: any } ? {} : undici.WebSocket;
+type _WebSocketInit = typeof globalThis extends { onmessage: any } ? {} : undici.WebSocketInit;
+
+declare global {
+    function fetch(
+        input: string | URL | Request,
+        init?: RequestInit,
+    ): Promise<Response>;
+
+    interface CloseEvent extends _CloseEvent {}
+    var CloseEvent: typeof globalThis extends { onmessage: any; CloseEvent: infer T } ? T : typeof undici.CloseEvent;
+
+    interface CloseEventInit extends _CloseEventInit {}
+
+    interface ErrorEvent extends _ErrorEvent {}
+    var ErrorEvent: typeof globalThis extends { onmessage: any; ErrorEvent: infer T } ? T : typeof undici.ErrorEvent;
+
+    interface ErrorEventInit extends _ErrorEventInit {}
+
+    interface EventSource extends _EventSource {}
+    var EventSource: typeof globalThis extends { onmessage: any; EventSource: infer T } ? T : typeof undici.EventSource;
+
+    interface EventSourceInit extends _EventSourceInit {}
+
+    interface FormData extends _FormData {}
+    var FormData: typeof globalThis extends { onmessage: any; FormData: infer T } ? T : typeof undici.FormData;
+
+    interface Headers extends _Headers {}
+    var Headers: typeof globalThis extends { onmessage: any; Headers: infer T } ? T : typeof undici.Headers;
+
+    interface MessageEvent extends _MessageEvent {}
+    var MessageEvent: typeof globalThis extends { onmessage: any; MessageEvent: infer T } ? T
+        : typeof undici.MessageEvent;
+
+    interface MessageEventInit extends _MessageEventInit {}
+
+    interface Request extends _Request {}
+    var Request: typeof globalThis extends { onmessage: any; Request: infer T } ? T : typeof undici.Request;
+
+    interface RequestInit extends _RequestInit {}
+
+    interface Response extends _Response {}
+    var Response: typeof globalThis extends { onmessage: any; Response: infer T } ? T : typeof undici.Response;
+
+    interface ResponseInit extends _ResponseInit {}
+
+    interface WebSocket extends _WebSocket {}
+    var WebSocket: typeof globalThis extends { onmessage: any; WebSocket: infer T } ? T : typeof undici.WebSocket;
+
+    interface WebSocketInit extends _WebSocketInit {}
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/importmeta.d.ts

@@ -0,0 +1,13 @@
+export {};
+
+import { URL } from "node:url";
+
+declare global {
+    interface ImportMeta {
+        dirname: string;
+        filename: string;
+        main: boolean;
+        url: string;
+        resolve(specifier: string, parent?: string | URL): string;
+    }
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/messaging.d.ts

@@ -0,0 +1,23 @@
+export {};
+
+import * as worker_threads from "node:worker_threads";
+
+type _BroadcastChannel = typeof globalThis extends { onmessage: any } ? {} : worker_threads.BroadcastChannel;
+type _MessageChannel = typeof globalThis extends { onmessage: any } ? {} : worker_threads.MessageChannel;
+type _MessagePort = typeof globalThis extends { onmessage: any } ? {} : worker_threads.MessagePort;
+
+declare global {
+    function structuredClone<T = any>(value: T, options?: worker_threads.StructuredSerializeOptions): T;
+
+    interface BroadcastChannel extends _BroadcastChannel {}
+    var BroadcastChannel: typeof globalThis extends { onmessage: any; BroadcastChannel: infer T } ? T
+        : typeof worker_threads.BroadcastChannel;
+
+    interface MessageChannel extends _MessageChannel {}
+    var MessageChannel: typeof globalThis extends { onmessage: any; MessageChannel: infer T } ? T
+        : typeof worker_threads.MessageChannel;
+
+    interface MessagePort extends _MessagePort {}
+    var MessagePort: typeof globalThis extends { onmessage: any; MessagePort: infer T } ? T
+        : typeof worker_threads.MessagePort;
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/navigator.d.ts

@@ -0,0 +1,25 @@
+export {};
+
+import { LockManager } from "worker_threads";
+
+// lib.webworker has `WorkerNavigator` rather than `Navigator`, so conditionals use `onabort` instead of `onmessage`
+type _Navigator = typeof globalThis extends { onabort: any } ? {} : Navigator;
+interface Navigator {
+    readonly hardwareConcurrency: number;
+    readonly language: string;
+    readonly languages: readonly string[];
+    readonly locks: LockManager;
+    readonly platform: string;
+    readonly userAgent: string;
+}
+
+declare global {
+    interface Navigator extends _Navigator {}
+    var Navigator: typeof globalThis extends { onabort: any; Navigator: infer T } ? T : {
+        prototype: Navigator;
+        new(): Navigator;
+    };
+
+    // Needs conditional inference for lib.dom and lib.webworker compatibility
+    var navigator: typeof globalThis extends { onmessage: any; navigator: infer T } ? T : Navigator;
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/performance.d.ts

@@ -0,0 +1,45 @@
+export {};
+
+import * as perf_hooks from "node:perf_hooks";
+
+type _Performance = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.Performance;
+type _PerformanceEntry = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceEntry;
+type _PerformanceMark = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceMark;
+type _PerformanceMeasure = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceMeasure;
+type _PerformanceObserver = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceObserver;
+type _PerformanceObserverEntryList = typeof globalThis extends { onmessage: any } ? {}
+    : perf_hooks.PerformanceObserverEntryList;
+type _PerformanceResourceTiming = typeof globalThis extends { onmessage: any } ? {}
+    : perf_hooks.PerformanceResourceTiming;
+
+declare global {
+    interface Performance extends _Performance {}
+    var Performance: typeof globalThis extends { onmessage: any; Performance: infer T } ? T
+        : typeof perf_hooks.Performance;
+
+    interface PerformanceEntry extends _PerformanceEntry {}
+    var PerformanceEntry: typeof globalThis extends { onmessage: any; PerformanceEntry: infer T } ? T
+        : typeof perf_hooks.PerformanceEntry;
+
+    interface PerformanceMark extends _PerformanceMark {}
+    var PerformanceMark: typeof globalThis extends { onmessage: any; PerformanceMark: infer T } ? T
+        : typeof perf_hooks.PerformanceMark;
+
+    interface PerformanceMeasure extends _PerformanceMeasure {}
+    var PerformanceMeasure: typeof globalThis extends { onmessage: any; PerformanceMeasure: infer T } ? T
+        : typeof perf_hooks.PerformanceMeasure;
+
+    interface PerformanceObserver extends _PerformanceObserver {}
+    var PerformanceObserver: typeof globalThis extends { onmessage: any; PerformanceObserver: infer T } ? T
+        : typeof perf_hooks.PerformanceObserver;
+
+    interface PerformanceObserverEntryList extends _PerformanceObserverEntryList {}
+    var PerformanceObserverEntryList: typeof globalThis extends
+        { onmessage: any; PerformanceObserverEntryList: infer T } ? T : typeof perf_hooks.PerformanceObserverEntryList;
+
+    interface PerformanceResourceTiming extends _PerformanceResourceTiming {}
+    var PerformanceResourceTiming: typeof globalThis extends { onmessage: any; PerformanceResourceTiming: infer T } ? T
+        : typeof perf_hooks.PerformanceResourceTiming;
+
+    var performance: typeof globalThis extends { onmessage: any; performance: infer T } ? T : perf_hooks.Performance;
+}

package/node_modules/@opentelemetry/sdk-node/node_modules/@types/node/web-globals/storage.d.ts

@@ -0,0 +1,24 @@
+export {};
+
+// These interfaces are absent from lib.webworker, so the conditionals use `onabort` rather than `onmessage`
+type _Storage = typeof globalThis extends { onabort: any } ? {} : Storage;
+interface Storage {
+    readonly length: number;
+    clear(): void;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string): void;
+    [key: string]: any;
+}
+
+declare global {
+    interface Storage extends _Storage {}
+    var Storage: typeof globalThis extends { onabort: any; Storage: infer T } ? T : {
+        prototype: Storage;
+        new(): Storage;
+    };
+
+    var localStorage: Storage;
+    var sessionStorage: Storage;
+}