omegon 0.8.4 → 0.9.0

package/node_modules/@types/node/v8.d.ts

@@ -4,9 +4,9 @@
  * ```js
  * import v8 from 'node:v8';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/v8.js)
  */
-declare module "node:v8" {
+declare module "v8" {
     import { NonSharedBuffer } from "node:buffer";
     import { Readable } from "node:stream";
     interface HeapSpaceInfo {
@@ -33,7 +33,6 @@ declare module "node: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;
@@ -94,9 +93,6 @@ declare module "node: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,
@@ -112,8 +108,7 @@ declare module "node:v8" {
      *   number_of_detached_contexts: 0,
      *   total_global_handles_size: 8192,
      *   used_global_handles_size: 3296,
-     *   external_memory: 318824,
-     *   total_allocated_bytes: 45224088
+     *   external_memory: 318824
      * }
      * ```
      * @since v1.0.0
@@ -309,6 +304,7 @@ declare module "node: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;
@@ -405,65 +401,6 @@ declare module "node:v8" {
      * @since v12.8.0
      */
     function getHeapCodeStatistics(): HeapCodeStatistics;
-    /**
-     * @since v25.0.0
-     */
-    interface SyncCPUProfileHandle {
-        /**
-         * Stopping collecting the profile and return the profile data.
-         * @since v25.0.0
-         */
-        stop(): string;
-        /**
-         * Stopping collecting the profile and the profile will be discarded.
-         * @since v25.0.0
-         */
-        [Symbol.dispose](): void;
-    }
-    /**
-     * @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>;
-    }
-    /**
-     * @since v24.9.0
-     */
-    interface HeapProfileHandle {
-        /**
-         * Stopping collecting the profile, then return a Promise that fulfills with an error or the
-         * profile data.
-         * @since v24.9.0
-         */
-        stop(): Promise<string>;
-        /**
-         * Stopping collecting the profile and the profile will be discarded.
-         * @since v24.9.0
-         */
-        [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;
@@ -494,7 +431,7 @@ declare module "node:v8" {
      * writeString('hello');
      * writeString('你好');
      * ```
-     * @since v23.10.0, v22.15.0
+     * @since v22.15.0
      */
     function isStringOneByteRepresentation(content: string): boolean;
     /**
@@ -644,7 +581,7 @@ declare module "node: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-v25.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-v22.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
      * @since v18.10.0, v16.18.0
      */
     function setHeapSnapshotNearHeapLimit(limit: number): void;
@@ -737,11 +674,6 @@ declare module "node: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;
@@ -983,6 +915,6 @@ declare module "node:v8" {
         function isBuildingSnapshot(): boolean;
     }
 }
-declare module "v8" {
-    export * from "node:v8";
+declare module "node:v8" {
+    export * from "v8";
 }

package/node_modules/@types/node/vm.d.ts

@@ -34,11 +34,11 @@
  *
  * console.log(x); // 1; y is not defined.
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/vm.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/vm.js)
  */
-declare module "node:vm" {
+declare module "vm" {
     import { NonSharedBuffer } from "node:buffer";
-    import { ImportAttributes, ImportPhase } from "node:module";
+    import { ImportAttributes } from "node:module";
     interface Context extends NodeJS.Dict<any> {}
     interface BaseOptions {
         /**
@@ -61,7 +61,6 @@ declare module "node:vm" {
         specifier: string,
         referrer: T,
         importAttributes: ImportAttributes,
-        phase: ImportPhase,
     ) => Module | Promise<Module>;
     interface ScriptOptions extends BaseOptions {
         /**
@@ -73,8 +72,7 @@ declare module "node: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-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         * @experimental
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
             | DynamicModuleLoader<Script>
@@ -119,8 +117,7 @@ declare module "node: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-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         * @experimental
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
             | DynamicModuleLoader<Script>
@@ -133,8 +130,7 @@ declare module "node: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-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         * @experimental
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
             | DynamicModuleLoader<Script>
@@ -153,8 +149,7 @@ declare module "node: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-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         * @experimental
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
             | DynamicModuleLoader<ReturnType<typeof compileFunction>>
@@ -197,8 +192,7 @@ declare module "node: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-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         * @experimental
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
             | DynamicModuleLoader<Context>
@@ -400,9 +394,9 @@ declare module "node:vm" {
     }
     /**
      * If the given `contextObject` is an object, the `vm.createContext()` method will
-     * [prepare that object](https://nodejs.org/docs/latest-v25.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
+     * [prepare that object](https://nodejs.org/docs/latest-v22.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-v25.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
+     * [`script.runInContext()`](https://nodejs.org/docs/latest-v22.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
@@ -677,12 +671,14 @@ declare module "node: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://tc39.es/ecma262/#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://262.ecma-international.org/14.0/#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.
+     * 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.
      *
      * Using a `vm.Module` object requires three distinct steps: creation/parsing,
      * linking, and evaluation. These three steps are illustrated in the following
@@ -710,7 +706,7 @@ declare module "node:vm" {
      * // Here, we attempt to obtain the default export from the module "foo", and
      * // put it into local binding "secret".
      *
-     * const rootModule = new vm.SourceTextModule(`
+     * const bar = new vm.SourceTextModule(`
      *   import s from 'foo';
      *   s;
      *   print(s);
@@ -720,48 +716,39 @@ declare module "node:vm" {
      * //
      * // "Link" the imported dependencies of this Module to it.
      * //
-     * // Obtain the requested dependencies of a SourceTextModule by
-     * // `sourceTextModule.moduleRequests` and resolve them.
+     * // 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.
      * //
      * // Even top-level Modules without dependencies must be explicitly linked. The
-     * // array passed to `sourceTextModule.linkRequests(modules)` can be
-     * // empty, however.
+     * // callback provided would never be called, however.
      * //
-     * // 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],
-     * ]);
-     *
-     * 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;
-     *
-     *     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, requestedModule);
-     *       // Resolve the dependencies of the new module as well.
-     *       resolveAndLinkDependencies(requestedModule);
-     *     }
-     *
-     *     return requestedModule;
-     *   });
-     *
-     *   module.linkRequests(requestedModules);
+     * // The link() method returns a Promise that will be resolved when all the
+     * // Promises returned by the linker resolve.
+     * //
+     * // 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.
+     *
+     * 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 });
+     *
+     *     // Using `contextifiedObject` instead of `referencingModule.context`
+     *     // here would work as well.
+     *   }
+     *   throw new Error(`Unable to resolve dependency: ${specifier}`);
      * }
-     *
-     * resolveAndLinkDependencies(rootModule);
-     * rootModule.instantiate();
+     * await bar.link(linker);
      *
      * // Step 3
      * //
@@ -769,12 +756,20 @@ declare module "node:vm" {
      * // resolve after the module has finished evaluating.
      *
      * // Prints 42.
-     * await rootModule.evaluate();
+     * await bar.evaluate();
      * ```
      * @since v13.0.0, v12.16.0
      * @experimental
      */
     class Module {
+        /**
+         * The specifiers of all dependencies of this module. The returned array is frozen
+         * to disallow any changes to it.
+         *
+         * Corresponds to the `[[RequestedModules]]` field of [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records) s in
+         * the ECMAScript specification.
+         */
+        dependencySpecifiers: readonly string[];
         /**
          * If the `module.status` is `'errored'`, this property contains the exception
          * thrown by the module during evaluation. If the status is anything else,
@@ -819,47 +814,19 @@ declare module "node: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.
-         *
-         * 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:
-         *
-         * 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.
-         *    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.
-         *    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.
-         *
-         * 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`.
+         * Evaluate the module.
          *
-         * 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.
+         * This must be called after the module has been linked; otherwise it will reject.
+         * It could be called also when the module has already been evaluated, in which
+         * case it will either do nothing if the initial evaluation ended in success
+         * (`module.status` is `'evaluated'`) or it will re-throw the exception that the
+         * initial evaluation resulted in (`module.status` is `'errored'`).
          *
-         * `evaluate()` could also be called again after the module has already been evaluated, in which case:
+         * This method cannot be called while the module is being evaluated
+         * (`module.status` is `'evaluating'`).
          *
-         * 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'`).
+         * 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.
          * @return Fulfills with `undefined` upon success.
          */
         evaluate(options?: ModuleEvaluateOptions): Promise<void>;
@@ -867,10 +834,6 @@ declare module "node: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:
@@ -915,30 +878,10 @@ declare module "node: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-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         * @experimental
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?: DynamicModuleLoader<SourceTextModule> | undefined;
     }
-    /**
-     * A `ModuleRequest` represents the request to import a module with given import attributes and phase.
-     * @since 24.4.0
-     */
-    interface ModuleRequest {
-        /**
-         * The specifier of the requested module.
-         */
-        specifier: string;
-        /**
-         * The `"with"` value passed to the `WithClause` in a `ImportDeclaration`, or an empty object if no value was
-         * provided.
-         */
-        attributes: ImportAttributes;
-        /**
-         * The phase of the requested module (`"source"` or `"evaluation"`).
-         */
-        phase: ImportPhase;
-    }
     /**
      * This feature is only available with the `--experimental-vm-modules` command
      * flag enabled.
@@ -951,163 +894,9 @@ declare module "node: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);
-        /**
-         * @deprecated Use `sourceTextModule.moduleRequests` instead.
-         */
-        readonly dependencySpecifiers: readonly string[];
-        /**
-         * Iterates over the dependency graph and returns `true` if any module in its
-         * dependencies or this module itself contains top-level `await` expressions,
-         * otherwise returns `false`.
-         *
-         * The search may be slow if the graph is big enough.
-         *
-         * This requires the module to be instantiated first. If the module is not
-         * instantiated yet, an error will be thrown.
-         * @since v24.9.0
-         */
-        hasAsyncGraph(): boolean;
-        /**
-         * Returns whether the module itself contains any top-level `await` expressions.
-         *
-         * This corresponds to the field `[[HasTLA]]` in [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records) in the
-         * ECMAScript specification.
-         * @since v24.9.0
-         */
-        hasTopLevelAwait(): boolean;
-        /**
-         * 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.
-         *
-         * For example, given a source text:
-         *
-         * ```js
-         * import foo from 'foo';
-         * import fooAlias from 'foo';
-         * import bar from './bar.js';
-         * import withAttrs from '../with-attrs.ts' with { arbitraryAttr: 'attr-val' };
-         * import source Module from 'wasm-mod.wasm';
-         * ```
-         *
-         * The value of the `sourceTextModule.moduleRequests` will be:
-         *
-         * ```js
-         * [
-         *   {
-         *     specifier: 'foo',
-         *     attributes: {},
-         *     phase: 'evaluation',
-         *   },
-         *   {
-         *     specifier: 'foo',
-         *     attributes: {},
-         *     phase: 'evaluation',
-         *   },
-         *   {
-         *     specifier: './bar.js',
-         *     attributes: {},
-         *     phase: 'evaluation',
-         *   },
-         *   {
-         *     specifier: '../with-attrs.ts',
-         *     attributes: { arbitraryAttr: 'attr-val' },
-         *     phase: 'evaluation',
-         *   },
-         *   {
-         *     specifier: 'wasm-mod.wasm',
-         *     attributes: {},
-         *     phase: 'source',
-         *   },
-         * ];
-         * ```
-         * @since v24.4.0
-         */
-        readonly moduleRequests: readonly ModuleRequest[];
     }
     interface SyntheticModuleOptions {
         /**
@@ -1155,7 +944,9 @@ declare module "node:vm" {
             options?: SyntheticModuleOptions,
         );
         /**
-         * This method sets the module export binding slots with the given value.
+         * 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.
          *
          * ```js
          * import vm from 'node:vm';
@@ -1164,6 +955,7 @@ declare module "node:vm" {
          *   m.setExport('x', 1);
          * });
          *
+         * await m.link(() => {});
          * await m.evaluate();
          *
          * assert.strictEqual(m.namespace.x, 1);
@@ -1184,7 +976,7 @@ declare module "node: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-v25.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-v22.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;
@@ -1203,6 +995,6 @@ declare module "node:vm" {
         const DONT_CONTEXTIFY: number;
     }
 }
-declare module "vm" {
-    export * from "node:vm";
+declare module "node:vm" {
+    export * from "vm";
 }