@types/node 24.12.0 → 25.5.0

node v24.12/v8.d.ts → node/v8.d.ts

@@ -4,9 +4,9 @@
  * ```js
  * import v8 from 'node:v8';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/v8.js)
  */
-declare module "v8" {
+declare module "node:v8" {
     import { NonSharedBuffer } from "node:buffer";
     import { Readable } from "node:stream";
     interface HeapSpaceInfo {
@@ -33,6 +33,7 @@ declare module "v8" {
         total_global_handles_size: number;
         used_global_handles_size: number;
         external_memory: number;
+        total_allocated_bytes: number;
     }
     interface HeapCodeStatistics {
         code_and_metadata_size: number;
@@ -93,6 +94,9 @@ declare module "v8" {
      * `external_memory` The value of external\_memory is the memory size of array
      * buffers and external strings.
      *
+     * `total_allocated_bytes` The value of total allocated bytes since the Isolate
+     * creation.
+     *
      * ```js
      * {
      *   total_heap_size: 7326976,
@@ -108,7 +112,8 @@ declare module "v8" {
      *   number_of_detached_contexts: 0,
      *   total_global_handles_size: 8192,
      *   used_global_handles_size: 3296,
-     *   external_memory: 318824
+     *   external_memory: 318824,
+     *   total_allocated_bytes: 45224088
      * }
      * ```
      * @since v1.0.0
@@ -304,7 +309,6 @@ declare module "v8" {
      * ```
      * @param ctor The constructor that can be used to search on the prototype chain in order to filter target objects in the heap.
      * @since v20.13.0
-     * @experimental
      */
     function queryObjects(ctor: Function): number | string[];
     function queryObjects(ctor: Function, options: { format: "count" }): number;
@@ -402,17 +406,17 @@ declare module "v8" {
      */
     function getHeapCodeStatistics(): HeapCodeStatistics;
     /**
-     * @since v24.12.0
+     * @since v25.0.0
      */
     interface SyncCPUProfileHandle {
         /**
          * Stopping collecting the profile and return the profile data.
-         * @since v24.12.0
+         * @since v25.0.0
          */
         stop(): string;
         /**
          * Stopping collecting the profile and the profile will be discarded.
-         * @since v24.12.0
+         * @since v25.0.0
          */
         [Symbol.dispose](): void;
     }
@@ -448,6 +452,18 @@ declare module "v8" {
          */
         [Symbol.asyncDispose](): Promise<void>;
     }
+    /**
+     * Starting a CPU profile then return a `SyncCPUProfileHandle` object.
+     * This API supports `using` syntax.
+     *
+     * ```js
+     * const handle = v8.startCpuProfile();
+     * const profile = handle.stop();
+     * console.log(profile);
+     * ```
+     * @since v25.0.0
+     */
+    function startCpuProfile(): SyncCPUProfileHandle;
     /**
      * V8 only supports `Latin-1/ISO-8859-1` and `UTF16` as the underlying representation of a string.
      * If the `content` uses `Latin-1/ISO-8859-1` as the underlying representation, this function will return true;
@@ -481,17 +497,6 @@ declare module "v8" {
      * @since v23.10.0, v22.15.0
      */
     function isStringOneByteRepresentation(content: string): boolean;
-    /**
-     * Starting a CPU profile then return a `SyncCPUProfileHandle` object. This API supports `using` syntax.
-     *
-     * ```js
-     * const handle = v8.startCpuProfile();
-     * const profile = handle.stop();
-     * console.log(profile);
-     * ```
-     * @since v24.12.0
-     */
-    function startCpuProfile(): SyncCPUProfileHandle;
     /**
      * @since v8.0.0
      */
@@ -639,7 +644,7 @@ declare module "v8" {
     function stopCoverage(): void;
     /**
      * The API is a no-op if `--heapsnapshot-near-heap-limit` is already set from the command line or the API is called more than once.
-     * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
+     * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v25.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
      * @since v18.10.0, v16.18.0
      */
     function setHeapSnapshotNearHeapLimit(limit: number): void;
@@ -732,6 +737,11 @@ declare module "v8" {
          * @since v19.6.0, v18.15.0
          */
         stop(): GCProfilerResult;
+        /**
+         * Stop collecting GC data, and discard the profile.
+         * @since v25.5.0
+         */
+        [Symbol.dispose](): void;
     }
     interface GCProfilerResult {
         version: number;
@@ -973,6 +983,6 @@ declare module "v8" {
         function isBuildingSnapshot(): boolean;
     }
 }
-declare module "node:v8" {
-    export * from "v8";
+declare module "v8" {
+    export * from "node:v8";
 }

node v24.12/vm.d.ts → node/vm.d.ts

@@ -34,9 +34,9 @@
  *
  * console.log(x); // 1; y is not defined.
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/vm.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/vm.js)
  */
-declare module "vm" {
+declare module "node:vm" {
     import { NonSharedBuffer } from "node:buffer";
     import { ImportAttributes, ImportPhase } from "node:module";
     interface Context extends NodeJS.Dict<any> {}
@@ -73,7 +73,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -119,7 +119,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -133,7 +133,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -153,7 +153,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -197,7 +197,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -400,9 +400,9 @@ declare module "vm" {
     }
     /**
      * If the given `contextObject` is an object, the `vm.createContext()` method will
-     * [prepare that object](https://nodejs.org/docs/latest-v24.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
+     * [prepare that object](https://nodejs.org/docs/latest-v25.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
      * and return a reference to it so that it can be used in calls to {@link runInContext} or
-     * [`script.runInContext()`](https://nodejs.org/docs/latest-v24.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
+     * [`script.runInContext()`](https://nodejs.org/docs/latest-v25.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
      * Inside such scripts, the global object will be wrapped by the `contextObject`, retaining all of its
      * existing properties but also having the built-in objects and functions any standard
      * [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global
@@ -748,7 +748,7 @@ declare module "vm" {
      *         // The "secret" variable refers to the global variable we added to
      *         // "contextifiedObject" when creating the context.
      *         export default secret;
-     *       `, { context: module.context });
+     *       `, { context: referencingModule.context });
      *       moduleMap.set(specifier, requestedModule);
      *       // Resolve the dependencies of the new module as well.
      *       resolveAndLinkDependencies(requestedModule);
@@ -819,32 +819,45 @@ declare module "vm" {
          */
         status: ModuleStatus;
         /**
-         * Evaluate the module and its depenendencies. Corresponds to the [Evaluate() concrete method](https://tc39.es/ecma262/#sec-moduleevaluation)
-         * field of [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records)s in the ECMAScript specification.
+         * Evaluate the module and its depenendencies. Corresponds to the [Evaluate() concrete method](https://tc39.es/ecma262/#sec-moduleevaluation) field of
+         * [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records)s in the ECMAScript specification.
          *
          * If the module is a `vm.SourceTextModule`, `evaluate()` must be called after the module has been instantiated;
          * otherwise `evaluate()` will return a rejected promise.
          *
-         * For a `vm.SourceTextModule`, the promise returned by `evaluate()` may be fulfilled either synchronously or asynchronously:
+         * For a `vm.SourceTextModule`, the promise returned by `evaluate()` may be fulfilled either
+         * synchronously or asynchronously:
+         *
          * 1. If the `vm.SourceTextModule` has no top-level `await` in itself or any of its dependencies, the promise will be
-         * fulfilled synchronously after the module and all its dependencies have been evaluated.
+         *    fulfilled _synchronously_ after the module and all its dependencies have been evaluated.
          *    1. If the evaluation succeeds, the promise will be _synchronously_ resolved to `undefined`.
-         *    2. If the evaluation results in an exception, the promise will be _synchronously_ rejected with the exception that causes the evaluation to fail, which is the same as `module.error`.
-         * 2. If the `vm.SourceTextModule` has top-level `await` in itself or any of its dependencies, the promise will be fulfilled asynchronously after the module and all its dependencies have been evaluated.
+         *    2. If the evaluation results in an exception, the promise will be _synchronously_ rejected with the exception
+         *       that causes the evaluation to fail, which is the same as `module.error`.
+         * 2. If the `vm.SourceTextModule` has top-level `await` in itself or any of its dependencies, the promise will be
+         *    fulfilled _asynchronously_ after the module and all its dependencies have been evaluated.
          *    1. If the evaluation succeeds, the promise will be _asynchronously_ resolved to `undefined`.
-         *    2. If the evaluation results in an exception, the promise will be _asynchronously_ rejected with the exception that causes the evaluation to fail.
+         *    2. If the evaluation results in an exception, the promise will be _asynchronously_ rejected with the exception
+         *       that causes the evaluation to fail.
+         *
+         * If the module is a `vm.SyntheticModule`, `evaluate()` always returns a promise that fulfills synchronously, see
+         * the specification of [Evaluate() of a Synthetic Module Record](https://tc39.es/ecma262/#sec-smr-Evaluate):
          *
-         * If the module is a `vm.SyntheticModule`, `evaluate()` always returns a promise that fulfills synchronously,
-         * see the specification of [Evaluate() of a Synthetic Module Record](https://tc39.es/ecma262/#sec-smr-Evaluate):
-         * 1. If the `evaluateCallback` passed to its constructor throws an exception synchronously, `evaluate()` returns a promise that will be synchronously rejected with that exception.
-         * 2. If the `evaluateCallback` does not throw an exception, `evaluate()` returns a promise that will be synchronously resolved to `undefined`.
+         * 1. If the `evaluateCallback` passed to its constructor throws an exception synchronously, `evaluate()` returns
+         *    a promise that will be synchronously rejected with that exception.
+         * 2. If the `evaluateCallback` does not throw an exception, `evaluate()` returns a promise that will be
+         *    synchronously resolved to `undefined`.
          *
-         * The `evaluateCallback` of a `vm.SyntheticModule` is executed synchronously within the `evaluate()` call, and its return value is discarded. This means if `evaluateCallback` is an asynchronous function, the promise
-         * returned by `evaluate()` will not reflect its asynchronous behavior, and any rejections from an asynchronous `evaluateCallback` will be lost.
+         * The `evaluateCallback` of a `vm.SyntheticModule` is executed synchronously within the `evaluate()` call, and its
+         * return value is discarded. This means if `evaluateCallback` is an asynchronous function, the promise returned by
+         * `evaluate()` will not reflect its asynchronous behavior, and any rejections from an asynchronous
+         * `evaluateCallback` will be lost.
          *
-         * evaluate() could also be called again after the module has already been evaluated, in which case:
-         * 1. If the initial evaluation ended in success (`module.status` is `'evaluated'`), it will do nothing and return a promise that resolves to `undefined`.
-         * 2. If the initial evaluation resulted in an exception (`module.status` is `'errored'`), it will re-reject the exception that the initial evaluation resulted in.
+         * `evaluate()` could also be called again after the module has already been evaluated, in which case:
+         *
+         * 1. If the initial evaluation ended in success (`module.status` is `'evaluated'`), it will do nothing
+         *    and return a promise that resolves to `undefined`.
+         * 2. If the initial evaluation resulted in an exception (`module.status` is `'errored'`), it will re-reject
+         *    the exception that the initial evaluation resulted in.
          *
          * This method cannot be called while the module is being evaluated (`module.status` is `'evaluating'`).
          * @return Fulfills with `undefined` upon success.
@@ -902,7 +915,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?: DynamicModuleLoader<SourceTextModule> | undefined;
@@ -1171,7 +1184,7 @@ declare module "vm" {
          * and `vm.compileFunction()` so that Node.js uses the default ESM loader from the main
          * context to load the requested module.
          *
-         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @since v21.7.0, v20.12.0
          */
         const USE_MAIN_CONTEXT_DEFAULT_LOADER: number;
@@ -1190,6 +1203,6 @@ declare module "vm" {
         const DONT_CONTEXTIFY: number;
     }
 }
-declare module "node:vm" {
-    export * from "vm";
+declare module "vm" {
+    export * from "node:vm";
 }

node v24.12/wasi.d.ts → node/wasi.d.ts

@@ -67,9 +67,9 @@
  * wat2wasm demo.wat
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/wasi.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/wasi.js)
  */
-declare module "wasi" {
+declare module "node:wasi" {
     interface WASIOptions {
         /**
          * An array of strings that the WebAssembly application will
@@ -197,6 +197,6 @@ declare module "wasi" {
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
     }
 }
-declare module "node:wasi" {
-    export * from "wasi";
+declare module "wasi" {
+    export * from "node:wasi";
 }

node v24.12/web-globals/abortcontroller.d.ts → node/web-globals/abortcontroller.d.ts

@@ -1,17 +1,42 @@
 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 {
+interface AbortSignal extends EventTarget, InternalEventTargetEventProperties<AbortSignalEventMap> {
     readonly aborted: boolean;
-    onabort: ((this: AbortSignal, ev: Event) => any) | null;
     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 {

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;
+}

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;
+}

node v24.12/web-globals/crypto.d.ts → node/web-globals/crypto.d.ts

@@ -2,17 +2,24 @@ 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;

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;
+}

node v24.12/web-globals/events.d.ts → node/web-globals/events.d.ts

@@ -1,5 +1,6 @@
 export {};
 
+type _AddEventListenerOptions = typeof globalThis extends { onmessage: any } ? {} : AddEventListenerOptions;
 interface AddEventListenerOptions extends EventListenerOptions {
     once?: boolean;
     passive?: boolean;
@@ -43,10 +44,12 @@ interface EventInit {
     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;
 }
@@ -72,6 +75,8 @@ interface EventTarget {
 }
 
 declare global {
+    interface AddEventListenerOptions extends _AddEventListenerOptions {}
+
     interface CustomEvent<T = any> extends _CustomEvent<T> {}
     var CustomEvent: typeof globalThis extends { onmessage: any; CustomEvent: infer T } ? T
         : {
@@ -86,6 +91,10 @@ declare global {
             new(type: string, eventInitDict?: EventInit): Event;
         };
 
+    interface EventListener extends _EventListener {}
+
+    interface EventListenerObject extends _EventListenerObject {}
+
     interface EventListenerOptions extends _EventListenerOptions {}
 
     interface EventTarget extends _EventTarget {}

node v24.12/web-globals/fetch.d.ts → node/web-globals/fetch.d.ts

@@ -4,6 +4,8 @@ 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;
@@ -28,6 +30,11 @@ declare global {
 
     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;
 

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;
+    }
+}

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;
+}

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;
+}