@venos-inc/venos 0.1.14 → 0.1.15

package/etc/mcp-server/node_modules/@types/node/vm.d.ts

@@ -17,7 +17,7 @@
  * code are reflected in the context object.
  *
  * ```js
- * import vm from 'node:vm';
+ * const vm = require('node:vm');
  *
  * const x = 1;
  *
@@ -34,10 +34,9 @@
  *
  * console.log(x); // 1; y is not defined.
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/vm.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/vm.js)
  */
 declare module "vm" {
-    import { NonSharedBuffer } from "node:buffer";
     import { ImportAttributes } from "node:module";
     interface Context extends NodeJS.Dict<any> {}
     interface BaseOptions {
@@ -57,25 +56,20 @@ declare module "vm" {
          */
         columnOffset?: number | undefined;
     }
-    type DynamicModuleLoader<T> = (
-        specifier: string,
-        referrer: T,
-        importAttributes: ImportAttributes,
-    ) => Module | Promise<Module>;
     interface ScriptOptions extends BaseOptions {
         /**
-         * Provides an optional data with V8's code cache data for the supplied source.
+         * V8's code cache data for the supplied source.
          */
-        cachedData?: NodeJS.ArrayBufferView | undefined;
+        cachedData?: Buffer | NodeJS.ArrayBufferView | undefined;
         /** @deprecated in favor of `script.createCachedData()` */
         produceCachedData?: boolean | undefined;
         /**
          * 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-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v20.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
-            | DynamicModuleLoader<Script>
+            | ((specifier: string, script: Script, importAttributes: ImportAttributes) => Module)
             | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
             | undefined;
     }
@@ -98,46 +92,41 @@ declare module "vm" {
          */
         breakOnSigint?: boolean | undefined;
     }
-    interface RunningScriptInNewContextOptions
-        extends RunningScriptOptions, Pick<CreateContextOptions, "microtaskMode">
-    {
+    interface RunningScriptInNewContextOptions extends RunningScriptOptions {
         /**
          * Human-readable name of the newly created context.
          */
-        contextName?: CreateContextOptions["name"] | undefined;
+        contextName?: CreateContextOptions["name"];
         /**
          * Origin corresponding to the newly created context for display purposes. The origin should be formatted like a URL,
          * but with only the scheme, host, and port (if necessary), like the value of the `url.origin` property of a `URL` object.
          * Most notably, this string should omit the trailing slash, as that denotes a path.
          */
-        contextOrigin?: CreateContextOptions["origin"] | undefined;
-        contextCodeGeneration?: CreateContextOptions["codeGeneration"] | undefined;
-    }
-    interface RunningCodeOptions extends RunningScriptOptions, Pick<ScriptOptions, "cachedData"> {
+        contextOrigin?: CreateContextOptions["origin"];
+        contextCodeGeneration?: CreateContextOptions["codeGeneration"];
         /**
-         * 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-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
          */
-        importModuleDynamically?:
-            | DynamicModuleLoader<Script>
-            | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
-            | undefined;
+        microtaskMode?: CreateContextOptions["microtaskMode"];
+    }
+    interface RunningCodeOptions extends RunningScriptOptions {
+        cachedData?: ScriptOptions["cachedData"];
+        importModuleDynamically?: ScriptOptions["importModuleDynamically"];
     }
-    interface RunningCodeInNewContextOptions
-        extends RunningScriptInNewContextOptions, Pick<ScriptOptions, "cachedData">
-    {
+    interface RunningCodeInNewContextOptions extends RunningScriptInNewContextOptions {
+        cachedData?: ScriptOptions["cachedData"];
+        importModuleDynamically?: ScriptOptions["importModuleDynamically"];
+    }
+    interface CompileFunctionOptions extends BaseOptions {
         /**
-         * 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-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * Provides an optional data with V8's code cache data for the supplied source.
          */
-        importModuleDynamically?:
-            | DynamicModuleLoader<Script>
-            | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
-            | undefined;
-    }
-    interface CompileFunctionOptions extends BaseOptions, Pick<ScriptOptions, "cachedData" | "produceCachedData"> {
+        cachedData?: Buffer | undefined;
+        /**
+         * Specifies whether to produce new cache data.
+         * @default false
+         */
+        produceCachedData?: boolean | undefined;
         /**
          * The sandbox/context in which the said function should be compiled in.
          */
@@ -146,15 +135,6 @@ declare module "vm" {
          * An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling
          */
         contextExtensions?: Object[] | undefined;
-        /**
-         * 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-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         */
-        importModuleDynamically?:
-            | DynamicModuleLoader<ReturnType<typeof compileFunction>>
-            | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
-            | undefined;
     }
     interface CreateContextOptions {
         /**
@@ -189,15 +169,6 @@ declare module "vm" {
          * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
          */
         microtaskMode?: "afterEvaluate" | undefined;
-        /**
-         * 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-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         */
-        importModuleDynamically?:
-            | DynamicModuleLoader<Context>
-            | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
-            | undefined;
     }
     type MeasureMemoryMode = "summary" | "detailed";
     interface MeasureMemoryOptions {
@@ -232,7 +203,7 @@ declare module "vm" {
          * The globals are contained in the `context` object.
          *
          * ```js
-         * import vm from 'node:vm';
+         * const vm = require('node:vm');
          *
          * const context = {
          *   animal: 'cat',
@@ -259,16 +230,9 @@ declare module "vm" {
          */
         runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any;
         /**
-         * This method is a shortcut to `script.runInContext(vm.createContext(options), options)`.
-         * It does several things at once:
-         *
-         * 1. Creates a new context.
-         * 2. If `contextObject` is an object, contextifies it with the new context.
-         *    If  `contextObject` is undefined, creates a new object and contextifies it.
-         *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
-         * 3. Runs the compiled code contained by the `vm.Script` object within the created context. The code
-         *    does not have access to the scope in which this method is called.
-         * 4. Returns the result.
+         * First contextifies the given `contextObject`, runs the compiled code contained
+         * by the `vm.Script` object within the created context, and returns the result.
+         * Running code does not have access to local scope.
          *
          * The following example compiles code that sets a global variable, then executes
          * the code multiple times in different contexts. The globals are set on and
@@ -286,22 +250,12 @@ declare module "vm" {
          *
          * console.log(contexts);
          * // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]
-         *
-         * // This would throw if the context is created from a contextified object.
-         * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary
-         * // global objects that can be frozen.
-         * const freezeScript = new vm.Script('Object.freeze(globalThis); globalThis;');
-         * const frozenContext = freezeScript.runInNewContext(vm.constants.DONT_CONTEXTIFY);
          * ```
          * @since v0.3.1
-         * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
-         * If `undefined`, an empty contextified object will be created for backwards compatibility.
+         * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
          * @return the result of the very last statement executed in the script.
          */
-        runInNewContext(
-            contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
-            options?: RunningScriptInNewContextOptions,
-        ): any;
+        runInNewContext(contextObject?: Context, options?: RunningScriptInNewContextOptions): any;
         /**
          * Runs the compiled code contained by the `vm.Script` within the context of the
          * current `global` object. Running code does not have access to local scope, but _does_ have access to the current `global` object.
@@ -310,7 +264,7 @@ declare module "vm" {
          * executes that code multiple times:
          *
          * ```js
-         * import vm from 'node:vm';
+         * const vm = require('node:vm');
          *
          * global.globalVar = 0;
          *
@@ -362,17 +316,17 @@ declare module "vm" {
          * ```
          * @since v10.6.0
          */
-        createCachedData(): NonSharedBuffer;
+        createCachedData(): Buffer;
         /** @deprecated in favor of `script.createCachedData()` */
-        cachedDataProduced?: boolean;
+        cachedDataProduced?: boolean | undefined;
         /**
          * When `cachedData` is supplied to create the `vm.Script`, this value will be set
          * to either `true` or `false` depending on acceptance of the data by V8.
          * Otherwise the value is `undefined`.
          * @since v5.7.0
          */
-        cachedDataRejected?: boolean;
-        cachedData?: NonSharedBuffer;
+        cachedDataRejected?: boolean | undefined;
+        cachedData?: Buffer | undefined;
         /**
          * When the script is compiled from a source that contains a source map magic
          * comment, this property will be set to the URL of the source map.
@@ -390,16 +344,16 @@ declare module "vm" {
          * ```
          * @since v19.1.0, v18.13.0
          */
-        sourceMapURL: string | undefined;
+        sourceMapURL?: string | undefined;
     }
     /**
-     * If the given `contextObject` is an object, the `vm.createContext()` method will
-     * [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-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
+     * If given a `contextObject`, the `vm.createContext()` method will
+     * [prepare that object](https://nodejs.org/docs/latest-v20.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 `{@link runInContext}` or
+     * [`script.runInContext()`](https://nodejs.org/docs/latest-v20.x/api/vm.html#scriptrunincontextcontextifiedobject-options). Inside such
+     * scripts, the `contextObject` will be the global object, 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
      * variables will remain unchanged.
      *
      * ```js
@@ -420,12 +374,7 @@ declare module "vm" {
      * ```
      *
      * If `contextObject` is omitted (or passed explicitly as `undefined`), a new,
-     * empty contextified object will be returned.
-     *
-     * When the global object in the newly created context is contextified, it has some quirks
-     * compared to ordinary global objects. For example, it cannot be frozen. To create a context
-     * without the contextifying quirks, pass `vm.constants.DONT_CONTEXTIFY` as the `contextObject`
-     * argument. See the documentation of `vm.constants.DONT_CONTEXTIFY` for details.
+     * empty `contextified` object will be returned.
      *
      * The `vm.createContext()` method is primarily useful for creating a single
      * context that can be used to run multiple scripts. For instance, if emulating a
@@ -436,17 +385,11 @@ declare module "vm" {
      * The provided `name` and `origin` of the context are made visible through the
      * Inspector API.
      * @since v0.3.1
-     * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
-     * If `undefined`, an empty contextified object will be created for backwards compatibility.
      * @return contextified object.
      */
-    function createContext(
-        contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
-        options?: CreateContextOptions,
-    ): Context;
+    function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
     /**
-     * Returns `true` if the given `object` object has been contextified using {@link createContext},
-     * or if it's the global object of a context created using `vm.constants.DONT_CONTEXTIFY`.
+     * Returns `true` if the given `object` object has been `contextified` using {@link createContext}.
      * @since v0.11.7
      */
     function isContext(sandbox: Context): boolean;
@@ -461,7 +404,7 @@ declare module "vm" {
      * The following example compiles and executes different scripts using a single `contextified` object:
      *
      * ```js
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      *
      * const contextObject = { globalVar: 1 };
      * vm.createContext(contextObject);
@@ -479,20 +422,12 @@ declare module "vm" {
      */
     function runInContext(code: string, contextifiedObject: Context, options?: RunningCodeOptions | string): any;
     /**
-     * This method is a shortcut to
-     * `(new vm.Script(code, options)).runInContext(vm.createContext(options), options)`.
-     * If `options` is a string, then it specifies the filename.
+     * The `vm.runInNewContext()` first contextifies the given `contextObject` (or
+     * creates a new `contextObject` if passed as `undefined`), compiles the `code`,
+     * runs it within the created context, then returns the result. Running code
+     * does not have access to the local scope.
      *
-     * It does several things at once:
-     *
-     * 1. Creates a new context.
-     * 2. If `contextObject` is an object, contextifies it with the new context.
-     *    If  `contextObject` is undefined, creates a new object and contextifies it.
-     *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
-     * 3. Compiles the code as a`vm.Script`
-     * 4. Runs the compield code within the created context. The code does not have access to the scope in
-     *    which this method is called.
-     * 5. Returns the result.
+     * If `options` is a string, then it specifies the filename.
      *
      * The following example compiles and executes code that increments a global
      * variable and sets a new one. These globals are contained in the `contextObject`.
@@ -508,21 +443,15 @@ declare module "vm" {
      * vm.runInNewContext('count += 1; name = "kitty"', contextObject);
      * console.log(contextObject);
      * // Prints: { animal: 'cat', count: 3, name: 'kitty' }
-     *
-     * // This would throw if the context is created from a contextified object.
-     * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary global objects that
-     * // can be frozen.
-     * const frozenContext = vm.runInNewContext('Object.freeze(globalThis); globalThis;', vm.constants.DONT_CONTEXTIFY);
      * ```
      * @since v0.3.1
      * @param code The JavaScript code to compile and run.
-     * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
-     * If `undefined`, an empty contextified object will be created for backwards compatibility.
+     * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
      * @return the result of the very last statement executed in the script.
      */
     function runInNewContext(
         code: string,
-        contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
+        contextObject?: Context,
         options?: RunningCodeInNewContextOptions | string,
     ): any;
     /**
@@ -536,7 +465,7 @@ declare module "vm" {
      * the JavaScript [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) function to run the same code:
      *
      * ```js
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      * let localVar = 'initial value';
      *
      * const vmResult = vm.runInThisContext('localVar = "vm";');
@@ -558,16 +487,16 @@ declare module "vm" {
      * context. The code passed to this VM context will have its own isolated scope.
      *
      * In order to run a simple web server using the `node:http` module the code passed
-     * to the context must either import `node:http` on its own, or have a
+     * to the context must either call `require('node:http')` on its own, or have a
      * reference to the `node:http` module passed to it. For instance:
      *
      * ```js
      * 'use strict';
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      *
      * const code = `
      * ((require) => {
-     * const http = require('node:http');
+     *   const http = require('node:http');
      *
      *   http.createServer((request, response) => {
      *     response.writeHead(200, { 'Content-Type': 'text/plain' });
@@ -600,7 +529,11 @@ declare module "vm" {
         code: string,
         params?: readonly string[],
         options?: CompileFunctionOptions,
-    ): Function & Pick<Script, "cachedData" | "cachedDataProduced" | "cachedDataRejected">;
+    ): Function & {
+        cachedData?: Script["cachedData"] | undefined;
+        cachedDataProduced?: Script["cachedDataProduced"] | undefined;
+        cachedDataRejected?: Script["cachedDataRejected"] | undefined;
+    };
     /**
      * Measure the memory known to V8 and used by all contexts known to the
      * current V8 isolate, or the main context.
@@ -614,7 +547,7 @@ declare module "vm" {
      * the memory occupied by each heap space in the current V8 instance.
      *
      * ```js
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      * // Measure the memory used by the main context.
      * vm.measureMemory({ mode: 'summary' })
      *   // This is the same as vm.measureMemory()
@@ -657,11 +590,16 @@ declare module "vm" {
      * @experimental
      */
     function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;
-    interface ModuleEvaluateOptions extends Pick<RunningScriptOptions, "breakOnSigint" | "timeout"> {}
+    interface ModuleEvaluateOptions {
+        timeout?: RunningScriptOptions["timeout"] | undefined;
+        breakOnSigint?: RunningScriptOptions["breakOnSigint"] | undefined;
+    }
     type ModuleLinker = (
         specifier: string,
         referencingModule: Module,
         extra: {
+            /** @deprecated Use `attributes` instead */
+            assert: ImportAttributes;
             attributes: ImportAttributes;
         },
     ) => Module | Promise<Module>;
@@ -864,23 +802,21 @@ declare module "vm" {
          */
         link(linker: ModuleLinker): Promise<void>;
     }
-    interface SourceTextModuleOptions extends Pick<ScriptOptions, "cachedData" | "columnOffset" | "lineOffset"> {
+    interface SourceTextModuleOptions {
         /**
          * String used in stack traces.
          * @default 'vm:module(i)' where i is a context-specific ascending index.
          */
         identifier?: string | undefined;
+        cachedData?: ScriptOptions["cachedData"] | undefined;
         context?: Context | undefined;
+        lineOffset?: BaseOptions["lineOffset"] | undefined;
+        columnOffset?: BaseOptions["columnOffset"] | undefined;
         /**
          * Called during evaluation of this module to initialize the `import.meta`.
          */
         initializeImportMeta?: ((meta: ImportMeta, module: SourceTextModule) => void) | undefined;
-        /**
-         * 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-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         */
-        importModuleDynamically?: DynamicModuleLoader<SourceTextModule> | undefined;
+        importModuleDynamically?: ScriptOptions["importModuleDynamically"] | undefined;
     }
     /**
      * This feature is only available with the `--experimental-vm-modules` command
@@ -919,7 +855,7 @@ declare module "vm" {
      * module graphs.
      *
      * ```js
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      *
      * const source = '{ "a": 1 }';
      * const module = new vm.SyntheticModule(['default'], function() {
@@ -968,31 +904,19 @@ declare module "vm" {
     }
     /**
      * Returns an object containing commonly used constants for VM operations.
-     * @since v21.7.0, v20.12.0
+     * @since v20.12.0
      */
     namespace constants {
         /**
+         * Stability: 1.1 - Active development
+         *
          * A constant that can be used as the `importModuleDynamically` option to `vm.Script`
          * 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-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
-         * @since v21.7.0, v20.12.0
+         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v20.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         const USE_MAIN_CONTEXT_DEFAULT_LOADER: number;
-        /**
-         * This constant, when used as the `contextObject` argument in vm APIs, instructs Node.js to create
-         * a context without wrapping its global object with another object in a Node.js-specific manner.
-         * As a result, the `globalThis` value inside the new context would behave more closely to an ordinary
-         * one.
-         *
-         * When `vm.constants.DONT_CONTEXTIFY` is used as the `contextObject` argument to {@link createContext},
-         * the returned object is a proxy-like object to the global object in the newly created context with
-         * fewer Node.js-specific quirks. It is reference equal to the `globalThis` value in the new context,
-         * can be modified from outside the context, and can be used to access built-ins in the new context directly.
-         * @since v22.8.0
-         */
-        const DONT_CONTEXTIFY: number;
     }
 }
 declare module "node:vm" {

package/etc/mcp-server/node_modules/@types/node/wasi.d.ts

@@ -9,7 +9,7 @@
  *
  * ```js
  * import { readFile } from 'node:fs/promises';
- * import { WASI } from 'node:wasi';
+ * import { WASI } from 'wasi';
  * import { argv, env } from 'node:process';
  *
  * const wasi = new WASI({
@@ -67,7 +67,7 @@
  * wat2wasm demo.wat
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/wasi.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/wasi.js)
  */
 declare module "wasi" {
     interface WASIOptions {
@@ -77,7 +77,7 @@ declare module "wasi" {
          * WASI command itself.
          * @default []
          */
-        args?: readonly string[] | undefined;
+        args?: string[] | undefined;
         /**
          * An object similar to `process.env` that the WebAssembly
          * application will see as its environment.