@types/node 24.7.2 → 24.8.0

node/http2.d.ts

@@ -284,61 +284,111 @@ declare module "http2" {
         addListener(event: "continue", listener: () => {}): this;
         addListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         addListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
         emit(event: "continue"): boolean;
-        emit(event: "headers", headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean;
+        emit(
+            event: "headers",
+            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: "push", headers: IncomingHttpHeaders, flags: number): boolean;
-        emit(event: "response", headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean;
+        emit(
+            event: "response",
+            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "continue", listener: () => {}): this;
         on(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         on(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(event: "continue", listener: () => {}): this;
         once(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         once(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(event: "continue", listener: () => {}): this;
         prependListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         prependListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "continue", listener: () => {}): this;
         prependOnceListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         prependOnceListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
@@ -976,6 +1026,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -987,6 +1038,7 @@ declare module "http2" {
             stream: ClientHttp2Stream,
             headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
             flags: number,
+            rawHeaders: string[],
         ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
@@ -998,6 +1050,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1013,6 +1066,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1028,6 +1082,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1043,6 +1098,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1160,7 +1216,12 @@ declare module "http2" {
         ): this;
         addListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
         emit(
@@ -1168,7 +1229,13 @@ declare module "http2" {
             session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
             socket: net.Socket | tls.TLSSocket,
         ): boolean;
-        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(
+            event: "stream",
+            stream: ServerHttp2Stream,
+            headers: IncomingHttpHeaders,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(
             event: "connect",
@@ -1179,7 +1246,12 @@ declare module "http2" {
         ): this;
         on(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(
@@ -1191,7 +1263,12 @@ declare module "http2" {
         ): this;
         once(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(
@@ -1203,7 +1280,12 @@ declare module "http2" {
         ): this;
         prependListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(
@@ -1215,7 +1297,12 @@ declare module "http2" {
         ): this;
         prependOnceListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
@@ -1384,7 +1471,12 @@ declare module "http2" {
         addListener(event: "sessionError", listener: (err: Error) => void): this;
         addListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: "timeout", listener: () => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1399,7 +1491,13 @@ declare module "http2" {
             session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
         ): boolean;
         emit(event: "sessionError", err: Error): boolean;
-        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(
+            event: "stream",
+            stream: ServerHttp2Stream,
+            headers: IncomingHttpHeaders,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: "timeout"): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(
@@ -1417,7 +1515,12 @@ declare module "http2" {
         on(event: "sessionError", listener: (err: Error) => void): this;
         on(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: "timeout", listener: () => void): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1436,7 +1539,12 @@ declare module "http2" {
         once(event: "sessionError", listener: (err: Error) => void): this;
         once(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: "timeout", listener: () => void): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1455,7 +1563,12 @@ declare module "http2" {
         prependListener(event: "sessionError", listener: (err: Error) => void): this;
         prependListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: "timeout", listener: () => void): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1474,7 +1587,12 @@ declare module "http2" {
         prependOnceListener(event: "sessionError", listener: (err: Error) => void): this;
         prependOnceListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: "timeout", listener: () => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -2195,8 +2313,8 @@ declare module "http2" {
          * will result in a `TypeError` being thrown.
          * @since v8.4.0
          */
-        writeHead(statusCode: number, headers?: OutgoingHttpHeaders): this;
-        writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders): this;
+        writeHead(statusCode: number, headers?: OutgoingHttpHeaders | readonly string[]): this;
+        writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders | readonly string[]): this;
         /**
          * Call `http2stream.pushStream()` with the given headers, and wrap the
          * given `Http2Stream` on a newly created `Http2ServerResponse` as the callback

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "24.7.2",
+    "version": "24.8.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -150,6 +150,6 @@
         "undici-types": "~7.14.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "4bf36d2d52de2aa8898ee24d026198a784567fa5a42adcae5e37b826951ff66d",
+    "typesPublisherContentHash": "bc6851a3467c10c05e3cd13590927c15bc180ff735647b20c43b43aa22890b3c",
     "typeScriptVersion": "5.2"
 }

node/sea.d.ts

@@ -150,4 +150,13 @@ declare module "node:sea" {
      * @since v20.12.0
      */
     function getRawAsset(key: AssetKey): ArrayBuffer;
+    /**
+     * This method can be used to retrieve an array of all the keys of assets
+     * embedded into the single-executable application.
+     * An error is thrown when not running inside a single-executable application.
+     * @since v24.8.0
+     * @returns An array containing all the keys of the assets
+     * embedded in the executable. If no assets are embedded, returns an empty array.
+     */
+    function getAssetKeys(): string[];
 }

node/stream.d.ts

@@ -1656,6 +1656,7 @@ declare module "stream" {
             ref(): void;
             unref(): void;
         }
+        // TODO: these should all take webstream arguments
         /**
          * Returns whether the stream has encountered an error.
          * @since v17.3.0, v16.14.0
@@ -1664,8 +1665,15 @@ declare module "stream" {
         /**
          * Returns whether the stream is readable.
          * @since v17.4.0, v16.14.0
+         * @returns Only returns `null` if `stream` is not a valid `Readable`, `Duplex` or `ReadableStream`.
          */
-        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
+        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean | null;
+        /**
+         * Returns whether the stream is writable.
+         * @since v20.0.0
+         * @returns Only returns `null` if `stream` is not a valid `Writable`, `Duplex` or `WritableStream`.
+         */
+        function isWritable(stream: Writable | NodeJS.WritableStream): boolean | null;
     }
     export = Stream;
 }

node/v8.d.ts

@@ -400,6 +400,22 @@ declare module "v8" {
      * @since v12.8.0
      */
     function getHeapCodeStatistics(): HeapCodeStatistics;
+    /**
+     * @since v24.8.0
+     */
+    interface CPUProfileHandle {
+        /**
+         * Stopping collecting the profile, then return a Promise that fulfills with an error or the
+         * profile data.
+         * @since v24.8.0
+         */
+        stop(): Promise<string>;
+        /**
+         * Stopping collecting the profile and the profile will be discarded.
+         * @since v24.8.0
+         */
+        [Symbol.asyncDispose](): Promise<void>;
+    }
     /**
      * 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;

node/vm.d.ts

@@ -676,14 +676,12 @@ declare module "vm" {
      * flag enabled.
      *
      * The `vm.Module` class provides a low-level interface for using
-     * ECMAScript modules in VM contexts. It is the counterpart of the `vm.Script` class that closely mirrors [Module Record](https://262.ecma-international.org/14.0/#sec-abstract-module-records) s as
-     * defined in the ECMAScript
+     * ECMAScript modules in VM contexts. It is the counterpart of the `vm.Script`
+     * class that closely mirrors [Module Record](https://tc39.es/ecma262/#sec-abstract-module-records)s as defined in the ECMAScript
      * specification.
      *
      * Unlike `vm.Script` however, every `vm.Module` object is bound to a context from
-     * its creation. Operations on `vm.Module` objects are intrinsically asynchronous,
-     * in contrast with the synchronous nature of `vm.Script` objects. The use of
-     * 'async' functions can help with manipulating `vm.Module` objects.
+     * its creation.
      *
      * Using a `vm.Module` object requires three distinct steps: creation/parsing,
      * linking, and evaluation. These three steps are illustrated in the following
@@ -711,7 +709,7 @@ declare module "vm" {
      * // Here, we attempt to obtain the default export from the module "foo", and
      * // put it into local binding "secret".
      *
-     * const bar = new vm.SourceTextModule(`
+     * const rootModule = new vm.SourceTextModule(`
      *   import s from 'foo';
      *   s;
      *   print(s);
@@ -721,39 +719,48 @@ declare module "vm" {
      * //
      * // "Link" the imported dependencies of this Module to it.
      * //
-     * // The provided linking callback (the "linker") accepts two arguments: the
-     * // parent module (`bar` in this case) and the string that is the specifier of
-     * // the imported module. The callback is expected to return a Module that
-     * // corresponds to the provided specifier, with certain requirements documented
-     * // in `module.link()`.
-     * //
-     * // If linking has not started for the returned Module, the same linker
-     * // callback will be called on the returned Module.
+     * // Obtain the requested dependencies of a SourceTextModule by
+     * // `sourceTextModule.moduleRequests` and resolve them.
      * //
      * // Even top-level Modules without dependencies must be explicitly linked. The
-     * // callback provided would never be called, however.
-     * //
-     * // The link() method returns a Promise that will be resolved when all the
-     * // Promises returned by the linker resolve.
+     * // array passed to `sourceTextModule.linkRequests(modules)` can be
+     * // empty, however.
      * //
-     * // Note: This is a contrived example in that the linker function creates a new
-     * // "foo" module every time it is called. In a full-fledged module system, a
-     * // cache would probably be used to avoid duplicated modules.
+     * // Note: This is a contrived example in that the resolveAndLinkDependencies
+     * // creates a new "foo" module every time it is called. In a full-fledged
+     * // module system, a cache would probably be used to avoid duplicated modules.
+     *
+     * const moduleMap = new Map([
+     *   ['root', rootModule],
+     * ]);
      *
-     * async function linker(specifier, referencingModule) {
-     *   if (specifier === 'foo') {
-     *     return new vm.SourceTextModule(`
-     *       // The "secret" variable refers to the global variable we added to
-     *       // "contextifiedObject" when creating the context.
-     *       export default secret;
-     *     `, { context: referencingModule.context });
+     * function resolveAndLinkDependencies(module) {
+     *   const requestedModules = module.moduleRequests.map((request) => {
+     *     // In a full-fledged module system, the resolveAndLinkDependencies would
+     *     // resolve the module with the module cache key `[specifier, attributes]`.
+     *     // In this example, we just use the specifier as the key.
+     *     const specifier = request.specifier;
      *
-     *     // Using `contextifiedObject` instead of `referencingModule.context`
-     *     // here would work as well.
-     *   }
-     *   throw new Error(`Unable to resolve dependency: ${specifier}`);
+     *     let requestedModule = moduleMap.get(specifier);
+     *     if (requestedModule === undefined) {
+     *       requestedModule = new vm.SourceTextModule(`
+     *         // The "secret" variable refers to the global variable we added to
+     *         // "contextifiedObject" when creating the context.
+     *         export default secret;
+     *       `, { context: referencingModule.context });
+     *       moduleMap.set(specifier, linkedModule);
+     *       // Resolve the dependencies of the new module as well.
+     *       resolveAndLinkDependencies(requestedModule);
+     *     }
+     *
+     *     return requestedModule;
+     *   });
+     *
+     *   module.linkRequests(requestedModules);
      * }
-     * await bar.link(linker);
+     *
+     * resolveAndLinkDependencies(rootModule);
+     * rootModule.instantiate();
      *
      * // Step 3
      * //
@@ -761,7 +768,7 @@ declare module "vm" {
      * // resolve after the module has finished evaluating.
      *
      * // Prints 42.
-     * await bar.evaluate();
+     * await rootModule.evaluate();
      * ```
      * @since v13.0.0, v12.16.0
      * @experimental
@@ -831,6 +838,10 @@ declare module "vm" {
          * Link module dependencies. This method must be called before evaluation, and
          * can only be called once per module.
          *
+         * Use `sourceTextModule.linkRequests(modules)` and
+         * `sourceTextModule.instantiate()` to link modules either synchronously or
+         * asynchronously.
+         *
          * The function is expected to return a `Module` object or a `Promise` that
          * eventually resolves to a `Module` object. The returned `Module` must satisfy the
          * following two invariants:
@@ -911,6 +922,39 @@ declare module "vm" {
     class SourceTextModule extends Module {
         /**
          * Creates a new `SourceTextModule` instance.
+         *
+         * Properties assigned to the `import.meta` object that are objects may
+         * allow the module to access information outside the specified `context`. Use
+         * `vm.runInContext()` to create objects in a specific context.
+         *
+         * ```js
+         * import vm from 'node:vm';
+         *
+         * const contextifiedObject = vm.createContext({ secret: 42 });
+         *
+         * const module = new vm.SourceTextModule(
+         *   'Object.getPrototypeOf(import.meta.prop).secret = secret;',
+         *   {
+         *     initializeImportMeta(meta) {
+         *       // Note: this object is created in the top context. As such,
+         *       // Object.getPrototypeOf(import.meta.prop) points to the
+         *       // Object.prototype in the top context rather than that in
+         *       // the contextified object.
+         *       meta.prop = {};
+         *     },
+         *   });
+         * // The module has an empty `moduleRequests` array.
+         * module.linkRequests([]);
+         * module.instantiate();
+         * await module.evaluate();
+         *
+         * // Now, Object.prototype.secret will be equal to 42.
+         * //
+         * // To fix this problem, replace
+         * //     meta.prop = {};
+         * // above with
+         * //     meta.prop = vm.runInContext('{}', contextifiedObject);
+         * ```
          * @param code JavaScript Module code to parse
          */
         constructor(code: string, options?: SourceTextModuleOptions);
@@ -918,6 +962,55 @@ declare module "vm" {
          * @deprecated Use `sourceTextModule.moduleRequests` instead.
          */
         readonly dependencySpecifiers: readonly string[];
+        /**
+         * Instantiate the module with the linked requested modules.
+         *
+         * This resolves the imported bindings of the module, including re-exported
+         * binding names. When there are any bindings that cannot be resolved,
+         * an error would be thrown synchronously.
+         *
+         * If the requested modules include cyclic dependencies, the
+         * `sourceTextModule.linkRequests(modules)` method must be called on all
+         * modules in the cycle before calling this method.
+         * @since v24.8.0
+         */
+        instantiate(): void;
+        /**
+         * Link module dependencies. This method must be called before evaluation, and
+         * can only be called once per module.
+         *
+         * The order of the module instances in the `modules` array should correspond to the order of
+         * `sourceTextModule.moduleRequests` being resolved. If two module requests have the same
+         * specifier and import attributes, they must be resolved with the same module instance or an
+         * `ERR_MODULE_LINK_MISMATCH` would be thrown. For example, when linking requests for this
+         * module:
+         *
+         * ```js
+         * import foo from 'foo';
+         * import source Foo from 'foo';
+         * ```
+         *
+         * The `modules` array must contain two references to the same instance, because the two
+         * module requests are identical but in two phases.
+         *
+         * If the module has no dependencies, the `modules` array can be empty.
+         *
+         * Users can use `sourceTextModule.moduleRequests` to implement the host-defined
+         * [HostLoadImportedModule](https://tc39.es/ecma262/#sec-HostLoadImportedModule) abstract operation in the ECMAScript specification,
+         * and using `sourceTextModule.linkRequests()` to invoke specification defined
+         * [FinishLoadingImportedModule](https://tc39.es/ecma262/#sec-FinishLoadingImportedModule), on the module with all dependencies in a batch.
+         *
+         * It's up to the creator of the `SourceTextModule` to determine if the resolution
+         * of the dependencies is synchronous or asynchronous.
+         *
+         * After each module in the `modules` array is linked, call
+         * `sourceTextModule.instantiate()`.
+         * @since v24.8.0
+         * @param modules Array of `vm.Module` objects that this module depends on.
+         * The order of the modules in the array is the order of
+         * `sourceTextModule.moduleRequests`.
+         */
+        linkRequests(modules: readonly Module[]): void;
         /**
          * The requested import dependencies of this module. The returned array is frozen
          * to disallow any changes to it.
@@ -1013,9 +1106,7 @@ declare module "vm" {
             options?: SyntheticModuleOptions,
         );
         /**
-         * This method is used after the module is linked to set the values of exports. If
-         * it is called before the module is linked, an `ERR_VM_MODULE_STATUS` error
-         * will be thrown.
+         * This method sets the module export binding slots with the given value.
          *
          * ```js
          * import vm from 'node:vm';
@@ -1024,7 +1115,6 @@ declare module "vm" {
          *   m.setExport('x', 1);
          * });
          *
-         * await m.link(() => {});
          * await m.evaluate();
          *
          * assert.strictEqual(m.namespace.x, 1);