@integration-app/react 0.1.2 → 0.1.4

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

@@ -0,0 +1,190 @@
+declare module 'v8' {
+    import { Readable } from 'stream';
+
+    interface HeapSpaceInfo {
+        space_name: string;
+        space_size: number;
+        space_used_size: number;
+        space_available_size: number;
+        physical_space_size: number;
+    }
+
+    // ** Signifies if the --zap_code_space option is enabled or not.  1 == enabled, 0 == disabled. */
+    type DoesZapCodeSpaceFlag = 0 | 1;
+
+    interface HeapInfo {
+        total_heap_size: number;
+        total_heap_size_executable: number;
+        total_physical_size: number;
+        total_available_size: number;
+        used_heap_size: number;
+        heap_size_limit: number;
+        malloced_memory: number;
+        peak_malloced_memory: number;
+        does_zap_garbage: DoesZapCodeSpaceFlag;
+        number_of_native_contexts: number;
+        number_of_detached_contexts: number;
+    }
+
+    interface HeapCodeStatistics {
+        code_and_metadata_size: number;
+        bytecode_and_metadata_size: number;
+        external_script_source_size: number;
+    }
+
+    /**
+     * Returns an integer representing a "version tag" derived from the V8 version, command line flags and detected CPU features.
+     * This is useful for determining whether a vm.Script cachedData buffer is compatible with this instance of V8.
+     */
+    function cachedDataVersionTag(): number;
+
+    function getHeapStatistics(): HeapInfo;
+    function getHeapSpaceStatistics(): HeapSpaceInfo[];
+    function setFlagsFromString(flags: string): void;
+    /**
+     * Generates a snapshot of the current V8 heap and returns a Readable
+     * Stream that may be used to read the JSON serialized representation.
+     * This conversation was marked as resolved by joyeecheung
+     * This JSON stream format is intended to be used with tools such as
+     * Chrome DevTools. The JSON schema is undocumented and specific to the
+     * V8 engine, and may change from one version of V8 to the next.
+     */
+    function getHeapSnapshot(): Readable;
+
+    /**
+     *
+     * @param fileName The file path where the V8 heap snapshot is to be
+     * saved. If not specified, a file name with the pattern
+     * `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
+     * generated, where `{pid}` will be the PID of the Node.js process,
+     * `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from
+     * the main Node.js thread or the id of a worker thread.
+     */
+    function writeHeapSnapshot(fileName?: string): string;
+
+    function getHeapCodeStatistics(): HeapCodeStatistics;
+
+    class Serializer {
+        /**
+         * Writes out a header, which includes the serialization format version.
+         */
+        writeHeader(): void;
+
+        /**
+         * Serializes a JavaScript value and adds the serialized representation to the internal buffer.
+         * This throws an error if value cannot be serialized.
+         */
+        writeValue(val: any): boolean;
+
+        /**
+         * Returns the stored internal buffer.
+         * This serializer should not be used once the buffer is released.
+         * Calling this method results in undefined behavior if a previous write has failed.
+         */
+        releaseBuffer(): Buffer;
+
+        /**
+         * Marks an ArrayBuffer as having its contents transferred out of band.\
+         * Pass the corresponding ArrayBuffer in the deserializing context to deserializer.transferArrayBuffer().
+         */
+        transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
+
+        /**
+         * Write a raw 32-bit unsigned integer.
+         */
+        writeUint32(value: number): void;
+
+        /**
+         * Write a raw 64-bit unsigned integer, split into high and low 32-bit parts.
+         */
+        writeUint64(hi: number, lo: number): void;
+
+        /**
+         * Write a JS number value.
+         */
+        writeDouble(value: number): void;
+
+        /**
+         * Write raw bytes into the serializer’s internal buffer.
+         * The deserializer will require a way to compute the length of the buffer.
+         */
+        writeRawBytes(buffer: NodeJS.TypedArray): void;
+    }
+
+    /**
+     * A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects,
+     * and only stores the part of their underlying `ArrayBuffers` that they are referring to.
+     */
+    class DefaultSerializer extends Serializer {
+    }
+
+    class Deserializer {
+        constructor(data: NodeJS.TypedArray);
+        /**
+         * Reads and validates a header (including the format version).
+         * May, for example, reject an invalid or unsupported wire format.
+         * In that case, an Error is thrown.
+         */
+        readHeader(): boolean;
+
+        /**
+         * Deserializes a JavaScript value from the buffer and returns it.
+         */
+        readValue(): any;
+
+        /**
+         * Marks an ArrayBuffer as having its contents transferred out of band.
+         * Pass the corresponding `ArrayBuffer` in the serializing context to serializer.transferArrayBuffer()
+         * (or return the id from serializer._getSharedArrayBufferId() in the case of SharedArrayBuffers).
+         */
+        transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
+
+        /**
+         * Reads the underlying wire format version.
+         * Likely mostly to be useful to legacy code reading old wire format versions.
+         * May not be called before .readHeader().
+         */
+        getWireFormatVersion(): number;
+
+        /**
+         * Read a raw 32-bit unsigned integer and return it.
+         */
+        readUint32(): number;
+
+        /**
+         * Read a raw 64-bit unsigned integer and return it as an array [hi, lo] with two 32-bit unsigned integer entries.
+         */
+        readUint64(): [number, number];
+
+        /**
+         * Read a JS number value.
+         */
+        readDouble(): number;
+
+        /**
+         * Read raw bytes from the deserializer’s internal buffer.
+         * The length parameter must correspond to the length of the buffer that was passed to serializer.writeRawBytes().
+         */
+        readRawBytes(length: number): Buffer;
+    }
+
+    /**
+     * A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects,
+     * and only stores the part of their underlying `ArrayBuffers` that they are referring to.
+     */
+    class DefaultDeserializer extends Deserializer {
+    }
+
+    /**
+     * Uses a `DefaultSerializer` to serialize value into a buffer.
+     */
+    function serialize(value: any): Buffer;
+
+    /**
+     * Uses a `DefaultDeserializer` with default options to read a JS value from a buffer.
+     */
+    function deserialize(data: NodeJS.TypedArray): any;
+}
+declare module 'node:v8' {
+    export * from 'v8';
+}

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

@@ -0,0 +1,155 @@
+declare module 'vm' {
+    interface Context extends NodeJS.Dict<any> { }
+    interface BaseOptions {
+        /**
+         * Specifies the filename used in stack traces produced by this script.
+         * Default: `''`.
+         */
+        filename?: string | undefined;
+        /**
+         * Specifies the line number offset that is displayed in stack traces produced by this script.
+         * Default: `0`.
+         */
+        lineOffset?: number | undefined;
+        /**
+         * Specifies the column number offset that is displayed in stack traces produced by this script.
+         * @default 0
+         */
+        columnOffset?: number | undefined;
+    }
+    interface ScriptOptions extends BaseOptions {
+        displayErrors?: boolean | undefined;
+        timeout?: number | undefined;
+        cachedData?: Buffer | undefined;
+        /** @deprecated in favor of `script.createCachedData()` */
+        produceCachedData?: boolean | undefined;
+    }
+    interface RunningScriptOptions extends BaseOptions {
+        /**
+         * When `true`, if an `Error` occurs while compiling the `code`, the line of code causing the error is attached to the stack trace.
+         * Default: `true`.
+         */
+        displayErrors?: boolean | undefined;
+        /**
+         * Specifies the number of milliseconds to execute code before terminating execution.
+         * If execution is terminated, an `Error` will be thrown. This value must be a strictly positive integer.
+         */
+        timeout?: number | undefined;
+        /**
+         * If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received.
+         * Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that.
+         * If execution is terminated, an `Error` will be thrown.
+         * Default: `false`.
+         */
+        breakOnSigint?: boolean | undefined;
+        /**
+         * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
+         */
+        microtaskMode?: 'afterEvaluate' | undefined;
+    }
+    interface CompileFunctionOptions extends BaseOptions {
+        /**
+         * Provides an optional data with V8's code cache data for the supplied source.
+         */
+        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.
+         */
+        parsingContext?: Context | undefined;
+
+        /**
+         * An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling
+         */
+        contextExtensions?: Object[] | undefined;
+    }
+
+    interface CreateContextOptions {
+        /**
+         * Human-readable name of the newly created context.
+         * @default 'VM Context i' Where i is an ascending numerical index of the created context.
+         */
+        name?: string | undefined;
+        /**
+         * Corresponds 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.
+         * @default ''
+         */
+        origin?: string | undefined;
+        codeGeneration?: {
+            /**
+             * If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc)
+             * will throw an EvalError.
+             * @default true
+             */
+            strings?: boolean | undefined;
+            /**
+             * If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError.
+             * @default true
+             */
+            wasm?: boolean | undefined;
+        } | undefined;
+        /**
+         * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
+         */
+        microtaskMode?: 'afterEvaluate' | undefined;
+    }
+
+    type MeasureMemoryMode = 'summary' | 'detailed';
+
+    interface MeasureMemoryOptions {
+        /**
+         * @default 'summary'
+         */
+        mode?: MeasureMemoryMode | undefined;
+        context?: Context | undefined;
+    }
+
+    interface MemoryMeasurement {
+        total: {
+            jsMemoryEstimate: number;
+            jsMemoryRange: [number, number];
+        };
+    }
+
+    class Script {
+        constructor(code: string, options?: ScriptOptions);
+        runInContext(contextifiedSandbox: Context, options?: RunningScriptOptions): any;
+        runInNewContext(sandbox?: Context, options?: RunningScriptOptions): any;
+        runInThisContext(options?: RunningScriptOptions): any;
+        createCachedData(): Buffer;
+        cachedDataRejected?: boolean | undefined;
+    }
+    function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
+    function isContext(sandbox: Context): boolean;
+    function runInContext(code: string, contextifiedSandbox: Context, options?: RunningScriptOptions | string): any;
+    function runInNewContext(code: string, sandbox?: Context, options?: RunningScriptOptions | string): any;
+    function runInThisContext(code: string, options?: RunningScriptOptions | string): any;
+    function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): Function;
+
+    /**
+     * Measure the memory known to V8 and used by the current execution context or a specified context.
+     *
+     * The format of the object that the returned Promise may resolve with is
+     * specific to the V8 engine and may change from one version of V8 to the next.
+     *
+     * The returned result is different from the statistics returned by
+     * `v8.getHeapSpaceStatistics()` in that `vm.measureMemory()` measures
+     * the memory reachable by V8 from a specific context, while
+     * `v8.getHeapSpaceStatistics()` measures the memory used by an instance
+     * of V8 engine, which can switch among multiple contexts that reference
+     * objects in the heap of one engine.
+     *
+     * @experimental
+     */
+    function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;
+}
+declare module 'node:vm' {
+    export * from 'vm';
+}

package/node_modules/@types/node/ts4.8/wasi.d.ts

@@ -0,0 +1,89 @@
+declare module 'wasi' {
+    interface WASIOptions {
+        /**
+         * An array of strings that the WebAssembly application will
+         * see as command line arguments. The first argument is the virtual path to the
+         * WASI command itself.
+         */
+        args?: string[] | undefined;
+
+        /**
+         * An object similar to `process.env` that the WebAssembly
+         * application will see as its environment.
+         */
+        env?: object | undefined;
+
+        /**
+         * This object represents the WebAssembly application's
+         * sandbox directory structure. The string keys of `preopens` are treated as
+         * directories within the sandbox. The corresponding values in `preopens` are
+         * the real paths to those directories on the host machine.
+         */
+        preopens?: NodeJS.Dict<string> | undefined;
+
+        /**
+         * By default, WASI applications terminate the Node.js
+         * process via the `__wasi_proc_exit()` function. Setting this option to `true`
+         * causes `wasi.start()` to return the exit code rather than terminate the
+         * process.
+         * @default false
+         */
+        returnOnExit?: boolean | undefined;
+
+        /**
+         * The file descriptor used as standard input in the WebAssembly application.
+         * @default 0
+         */
+        stdin?: number | undefined;
+
+        /**
+         * The file descriptor used as standard output in the WebAssembly application.
+         * @default 1
+         */
+        stdout?: number | undefined;
+
+        /**
+         * The file descriptor used as standard error in the WebAssembly application.
+         * @default 2
+         */
+        stderr?: number | undefined;
+    }
+
+    class WASI {
+        constructor(options?: WASIOptions);
+        /**
+         *
+         * Attempt to begin execution of `instance` by invoking its `_start()` export.
+         * If `instance` does not contain a `_start()` export, then `start()` attempts to
+         * invoke the `__wasi_unstable_reactor_start()` export. If neither of those exports
+         * is present on `instance`, then `start()` does nothing.
+         *
+         * `start()` requires that `instance` exports a [`WebAssembly.Memory`][] named
+         * `memory`. If `instance` does not have a `memory` export an exception is thrown.
+         *
+         * If `start()` is called more than once, an exception is thrown.
+         */
+        start(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
+
+        /**
+         * Attempt to initialize `instance` as a WASI reactor by invoking its `_initialize()` export, if it is present.
+         * If `instance` contains a `_start()` export, then an exception is thrown.
+         *
+         * `start()` requires that `instance` exports a [`WebAssembly.Memory`][] named
+         * `memory`. If `instance` does not have a `memory` export an exception is thrown.
+         *
+         * If `initialize()` is called more than once, an exception is thrown.
+         */
+        initialize(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
+
+        /**
+         * Is an object that implements the WASI system call API. This object
+         * should be passed as the `wasi_snapshot_preview1` import during the instantiation of a
+         * [`WebAssembly.Instance`][].
+         */
+        readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
+    }
+}
+declare module 'node:wasi' {
+    export * from 'wasi';
+}

package/node_modules/@types/node/ts4.8/worker_threads.d.ts

@@ -0,0 +1,241 @@
+declare module 'worker_threads' {
+    import { Context } from 'vm';
+    import EventEmitter = require('events');
+    import { Readable, Writable } from 'stream';
+    import { URL } from 'url';
+    import { FileHandle } from 'fs/promises';
+
+    const isMainThread: boolean;
+    const parentPort: null | MessagePort;
+    const resourceLimits: ResourceLimits;
+    const SHARE_ENV: unique symbol;
+    const threadId: number;
+    const workerData: any;
+
+    class MessageChannel {
+        readonly port1: MessagePort;
+        readonly port2: MessagePort;
+    }
+
+    type TransferListItem = ArrayBuffer | MessagePort | FileHandle;
+
+    class MessagePort extends EventEmitter {
+        close(): void;
+        postMessage(value: any, transferList?: ReadonlyArray<TransferListItem>): void;
+        ref(): void;
+        unref(): void;
+        start(): void;
+
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "message", listener: (value: any) => void): this;
+        addListener(event: "messageerror", listener: (error: Error) => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        emit(event: "close"): boolean;
+        emit(event: "message", value: any): boolean;
+        emit(event: "messageerror", error: Error): boolean;
+        emit(event: string | symbol, ...args: any[]): boolean;
+
+        on(event: "close", listener: () => void): this;
+        on(event: "message", listener: (value: any) => void): this;
+        on(event: "messageerror", listener: (error: Error) => void): this;
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        once(event: "close", listener: () => void): this;
+        once(event: "message", listener: (value: any) => void): this;
+        once(event: "messageerror", listener: (error: Error) => void): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "message", listener: (value: any) => void): this;
+        prependListener(event: "messageerror", listener: (error: Error) => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "message", listener: (value: any) => void): this;
+        prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        removeListener(event: "close", listener: () => void): this;
+        removeListener(event: "message", listener: (value: any) => void): this;
+        removeListener(event: "messageerror", listener: (error: Error) => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        off(event: "close", listener: () => void): this;
+        off(event: "message", listener: (value: any) => void): this;
+        off(event: "messageerror", listener: (error: Error) => void): this;
+        off(event: string | symbol, listener: (...args: any[]) => void): this;
+    }
+
+    interface WorkerOptions {
+        /**
+         * List of arguments which would be stringified and appended to
+         * `process.argv` in the worker. This is mostly similar to the `workerData`
+         * but the values will be available on the global `process.argv` as if they
+         * were passed as CLI options to the script.
+         */
+        argv?: any[] | undefined;
+        env?: NodeJS.Dict<string> | typeof SHARE_ENV | undefined;
+        eval?: boolean | undefined;
+        workerData?: any;
+        stdin?: boolean | undefined;
+        stdout?: boolean | undefined;
+        stderr?: boolean | undefined;
+        execArgv?: string[] | undefined;
+        resourceLimits?: ResourceLimits | undefined;
+        /**
+         * Additional data to send in the first worker message.
+         */
+        transferList?: TransferListItem[] | undefined;
+        trackUnmanagedFds?: boolean | undefined;
+    }
+
+    interface ResourceLimits {
+        /**
+         * The maximum size of a heap space for recently created objects.
+         */
+        maxYoungGenerationSizeMb?: number | undefined;
+        /**
+         * The maximum size of the main heap in MB.
+         */
+        maxOldGenerationSizeMb?: number | undefined;
+        /**
+         * The size of a pre-allocated memory range used for generated code.
+         */
+        codeRangeSizeMb?: number | undefined;
+        /**
+         * The default maximum stack size for the thread. Small values may lead to unusable Worker instances.
+         * @default 4
+         */
+        stackSizeMb?: number | undefined;
+    }
+
+    class Worker extends EventEmitter {
+        readonly stdin: Writable | null;
+        readonly stdout: Readable;
+        readonly stderr: Readable;
+        readonly threadId: number;
+        readonly resourceLimits?: ResourceLimits | undefined;
+
+        /**
+         * @param filename  The path to the Worker’s main script or module.
+         *                  Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with ./ or ../,
+         *                  or a WHATWG URL object using file: protocol. If options.eval is true, this is a string containing JavaScript code rather than a path.
+         */
+        constructor(filename: string | URL, options?: WorkerOptions);
+
+        postMessage(value: any, transferList?: ReadonlyArray<TransferListItem>): void;
+        ref(): void;
+        unref(): void;
+        /**
+         * Stop all JavaScript execution in the worker thread as soon as possible.
+         * Returns a Promise for the exit code that is fulfilled when the `exit` event is emitted.
+         */
+        terminate(): Promise<number>;
+
+        /**
+         * Returns a readable stream for a V8 snapshot of the current state of the Worker.
+         * See [`v8.getHeapSnapshot()`][] for more details.
+         *
+         * If the Worker thread is no longer running, which may occur before the
+         * [`'exit'` event][] is emitted, the returned `Promise` will be rejected
+         * immediately with an [`ERR_WORKER_NOT_RUNNING`][] error
+         */
+        getHeapSnapshot(): Promise<Readable>;
+
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "exit", listener: (exitCode: number) => void): this;
+        addListener(event: "message", listener: (value: any) => void): this;
+        addListener(event: "messageerror", listener: (error: Error) => void): this;
+        addListener(event: "online", listener: () => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        emit(event: "error", err: Error): boolean;
+        emit(event: "exit", exitCode: number): boolean;
+        emit(event: "message", value: any): boolean;
+        emit(event: "messageerror", error: Error): boolean;
+        emit(event: "online"): boolean;
+        emit(event: string | symbol, ...args: any[]): boolean;
+
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "exit", listener: (exitCode: number) => void): this;
+        on(event: "message", listener: (value: any) => void): this;
+        on(event: "messageerror", listener: (error: Error) => void): this;
+        on(event: "online", listener: () => void): this;
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "exit", listener: (exitCode: number) => void): this;
+        once(event: "message", listener: (value: any) => void): this;
+        once(event: "messageerror", listener: (error: Error) => void): this;
+        once(event: "online", listener: () => void): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "exit", listener: (exitCode: number) => void): this;
+        prependListener(event: "message", listener: (value: any) => void): this;
+        prependListener(event: "messageerror", listener: (error: Error) => void): this;
+        prependListener(event: "online", listener: () => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "exit", listener: (exitCode: number) => void): this;
+        prependOnceListener(event: "message", listener: (value: any) => void): this;
+        prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
+        prependOnceListener(event: "online", listener: () => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        removeListener(event: "error", listener: (err: Error) => void): this;
+        removeListener(event: "exit", listener: (exitCode: number) => void): this;
+        removeListener(event: "message", listener: (value: any) => void): this;
+        removeListener(event: "messageerror", listener: (error: Error) => void): this;
+        removeListener(event: "online", listener: () => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        off(event: "error", listener: (err: Error) => void): this;
+        off(event: "exit", listener: (exitCode: number) => void): this;
+        off(event: "message", listener: (value: any) => void): this;
+        off(event: "messageerror", listener: (error: Error) => void): this;
+        off(event: "online", listener: () => void): this;
+        off(event: string | symbol, listener: (...args: any[]) => void): this;
+    }
+
+    /**
+     * Mark an object as not transferable.
+     * If `object` occurs in the transfer list of a `port.postMessage()` call, it will be ignored.
+     *
+     * In particular, this makes sense for objects that can be cloned, rather than transferred,
+     * and which are used by other objects on the sending side. For example, Node.js marks
+     * the `ArrayBuffer`s it uses for its Buffer pool with this.
+     *
+     * This operation cannot be undone.
+     */
+    function markAsUntransferable(object: object): void;
+
+    /**
+     * Transfer a `MessagePort` to a different `vm` Context. The original `port`
+     * object will be rendered unusable, and the returned `MessagePort` instance will
+     * take its place.
+     *
+     * The returned `MessagePort` will be an object in the target context, and will
+     * inherit from its global `Object` class. Objects passed to the
+     * `port.onmessage()` listener will also be created in the target context
+     * and inherit from its global `Object` class.
+     *
+     * However, the created `MessagePort` will no longer inherit from
+     * `EventEmitter`, and only `port.onmessage()` can be used to receive
+     * events using it.
+     */
+    function moveMessagePortToContext(port: MessagePort, context: Context): MessagePort;
+
+    /**
+     * Receive a single message from a given `MessagePort`. If no message is available,
+     * `undefined` is returned, otherwise an object with a single `message` property
+     * that contains the message payload, corresponding to the oldest message in the
+     * `MessagePort`’s queue.
+     */
+    function receiveMessageOnPort(port: MessagePort): { message: any } | undefined;
+}
+declare module 'node:worker_threads' {
+    export * from 'worker_threads';
+}