@automattic/vip 4.1.3 → 4.1.5

package/node_modules/@types/node/test/reporters.d.ts

@@ -9,6 +9,7 @@ declare module "node:test/reporters" {
         | { type: "test:enqueue"; data: EventData.TestEnqueue }
         | { type: "test:fail"; data: EventData.TestFail }
         | { type: "test:interrupted"; data: EventData.TestInterrupted }
+        | { type: "test:log"; data: EventData.TestLog }
         | { type: "test:pass"; data: EventData.TestPass }
         | { type: "test:plan"; data: EventData.TestPlan }
         | { type: "test:start"; data: EventData.TestStart }

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

@@ -375,6 +375,7 @@ declare module "node:test" {
             "test:enqueue": [data: EventData.TestEnqueue];
             "test:fail": [data: EventData.TestFail];
             "test:interrupted": [data: EventData.TestInterrupted];
+            "test:log": [data: EventData.TestLog];
             "test:pass": [data: EventData.TestPass];
             "test:plan": [data: EventData.TestPlan];
             "test:start": [data: EventData.TestStart];
@@ -455,6 +456,13 @@ declare module "node:test" {
                  * `undefined` if the test was run through the REPL.
                  */
                 column?: number;
+                /**
+                 * The path of the test file that was
+                 * executed as the entry point of the child process that emitted this event.
+                 * Only present when tests run with process isolation. May differ from
+                 * `file` when the test is defined in a module imported by the entry file.
+                 */
+                entryFile?: string;
                 /**
                  * The path of the test file, `undefined` if test was run through the REPL.
                  */
@@ -677,6 +685,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The `testId` of the enclosing test, or
+                 * `undefined` for top-level tests. Lets custom reporters track lineage
+                 * when concurrent siblings at the same nesting level interleave.
+                 */
+                parentId: number | undefined;
                 /**
                  * The flattened lowercased tags declared on the test
                  * and its ancestor suites, in declaration order. Empty for untagged tests.
@@ -711,6 +725,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The `testId` of the enclosing test, or
+                 * `undefined` for top-level tests. Lets custom reporters track lineage
+                 * when concurrent siblings at the same nesting level interleave.
+                 */
+                parentId: number | undefined;
                 /**
                  * The flattened lowercased tags declared on the test
                  * and its ancestor suites, in declaration order. Empty for untagged tests.
@@ -738,6 +758,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The `testId` of the enclosing test, or
+                 * `undefined` for top-level tests. Lets custom reporters track lineage
+                 * when concurrent siblings at the same nesting level interleave.
+                 */
+                parentId: number | undefined;
                 /**
                  * The flattened lowercased tags declared on the test
                  * and its ancestor suites, in declaration order. Empty for untagged tests.
@@ -789,6 +815,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The `testId` of the enclosing test, or
+                 * `undefined` for top-level tests. Lets custom reporters track lineage
+                 * when concurrent siblings at the same nesting level interleave.
+                 */
+                parentId: number | undefined;
                 /**
                  * The flattened lowercased tags declared on the test
                  * and its ancestor suites, in declaration order. Empty for untagged tests.
@@ -821,6 +853,36 @@ declare module "node:test" {
                  */
                 tests: TestStart[];
             }
+            interface TestLog extends LocationInfo {
+                /**
+                 * The structured payload passed to `context.log`, or
+                 * `undefined` if none was provided. The test runner does not interpret this
+                 * value.
+                 */
+                data: unknown;
+                /**
+                 * The log message.
+                 */
+                message: string;
+                /**
+                 * The test name.
+                 */
+                name: string;
+                /**
+                 * The nesting level of the test.
+                 */
+                nesting: number;
+                /**
+                 * The `testId` of the enclosing test, or
+                 * `undefined` for top-level tests.
+                 */
+                parentId: number | undefined;
+                /**
+                 * A numeric identifier for the test instance that emitted
+                 * the log message.
+                 */
+                testId: number;
+            }
             interface TestPass extends LocationInfo {
                 /**
                  * Additional execution metadata.
@@ -856,6 +918,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The `testId` of the enclosing test, or
+                 * `undefined` for top-level tests. Lets custom reporters track lineage
+                 * when concurrent siblings at the same nesting level interleave.
+                 */
+                parentId: number | undefined;
                 /**
                  * The flattened lowercased tags declared on the test
                  * and its ancestor suites, in declaration order. Empty for untagged tests.
@@ -900,6 +968,12 @@ declare module "node:test" {
                  * The nesting level of the test.
                  */
                 nesting: number;
+                /**
+                 * The `testId` of the enclosing test, or
+                 * `undefined` for top-level tests. Lets custom reporters track lineage
+                 * when concurrent siblings at the same nesting level interleave.
+                 */
+                parentId: number | undefined;
                 /**
                  * The flattened lowercased tags declared on the test
                  * and its ancestor suites, in declaration order. Empty for untagged tests.
@@ -1094,6 +1168,25 @@ declare module "node:test" {
              * @param message Message to be reported.
              */
             diagnostic(message: string): void;
+            /**
+             * This function is used to write a log message to the output. Unlike
+             * `context.diagnostic`, the resulting `'test:log'` event is emitted
+             * immediately, in the order that the tests execute, rather than being buffered
+             * until the test reports its results. This function does not return a value.
+             *
+             * ```js
+             * test('top level test', (t) => {
+             *   t.log('fetched user', { userId: 42 });
+             *   t.log('retrying flaky endpoint', { attempt: 3 });
+             * });
+             * ```
+             * @since v26.6.0
+             * @param message Message to be reported.
+             * @param data Optional structured payload attached to the message. The test
+             * runner passes it through untouched. When tests run with process isolation,
+             * this value must be compatible with the [HTML structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).
+             */
+            log(message: string, data?: unknown): void;
             /**
              * The absolute path of the test file that created the current test. If a test file imports
              * additional modules that generate tests, the imported tests will return the path of the root test file.
@@ -1456,6 +1549,21 @@ declare module "node:test" {
              * @param message A diagnostic message to output.
              */
             diagnostic(message: string): void;
+            /**
+             * Write a log message to the output. The resulting `'test:log'` event is
+             * emitted immediately, in the order that the tests execute.
+             *
+             * ```js
+             * test.describe('my suite', (suite) => {
+             *   suite.log('Suite log message');
+             * });
+             * ```
+             * @since v26.6.0
+             * @param message Message to be reported.
+             * @param data Optional structured payload attached to the message. The test
+             * runner passes it through untouched.
+             */
+            log(message: string, data?: unknown): void;
         }
         interface TestOptions {
             /**

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

@@ -219,6 +219,13 @@ declare module "node:tls" {
          * @since v0.11.4
          */
         authorized: boolean;
+        /**
+         * The negotiated ALPN protocol. This is `null` before the handshake completes.
+         * Once the handshake completes, it settles as either the negotiated protocol
+         * name, or `false` if the peers did not negotiate an ALPN protocol.
+         * @since v6.0.0
+         */
+        alpnProtocol: string | false | null;
         /**
          * Returns the reason why the peer's certificate was not been verified. This
          * property is set only when `tlsSocket.authorized === false`.
@@ -230,16 +237,6 @@ declare module "node:tls" {
          * @since v0.11.4
          */
         encrypted: true;
-        /**
-         * String containing the selected ALPN protocol.
-         * Before a handshake has completed, this value is always null.
-         * When a handshake is completed but not ALPN protocol was selected, tlsSocket.alpnProtocol equals false.
-         */
-        alpnProtocol: string | false | null;
-        /**
-         * String containing the server name requested via SNI (Server Name Indication) TLS extension.
-         */
-        servername: string | false | null;
         /**
          * Returns an object representing the local certificate. The returned object has
          * some properties corresponding to the fields of the certificate.
@@ -270,11 +267,19 @@ declare module "node:tls" {
          */
         getCipher(): CipherNameAndProtocol;
         /**
-         * Returns an object representing the type, name, and size of parameter of
-         * an ephemeral key exchange in `perfect forward secrecy` on a client
-         * connection. It returns an empty object when the key exchange is not
-         * ephemeral. As this is only supported on a client socket; `null` is returned
-         * if called on a server socket. The supported types are `'DH'` and `'ECDH'`. The `name` property is available only when type is `'ECDH'`.
+         * Returns an object describing ephemeral key agreement in [perfect forward
+         * secrecy](https://nodejs.org/docs/latest-v26.x/api/tls.html#perfect-forward-secrecy) on a client connection. It returns an empty object when the key
+         * agreement is not ephemeral. As this is only supported on a client socket;
+         * `null` is returned if called on a server socket. The supported types are `'DH'`,
+         * `'ECDH'`, and `'TLSGroup'`. For `'DH'` and `'ECDH'`, the object describes peer
+         * temporary key parameters. For `'TLSGroup'`, the object identifies the negotiated
+         * TLS Supported Group used for key agreement when a peer temporary key object is
+         * not available.
+         *
+         * The `name` property is available only when type is `'ECDH'` or `'TLSGroup'`. The
+         * `size` property is not available when type is `'TLSGroup'`. For `'TLSGroup'`,
+         * `name` is the negotiated TLS Supported Group name. Standardized TLS group names
+         * and code points are listed in the [IANA TLS Supported Groups registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8).
          *
          * For example: `{ type: 'ECDH', name: 'prime256v1', size: 256 }`.
          * @since v5.0.0
@@ -394,6 +399,13 @@ declare module "node:tls" {
             },
             callback: (err: Error | null) => void,
         ): undefined | boolean;
+        /**
+         * The SNI (Server Name Indication) host name associated with the socket. This is
+         * `null` before the handshake completes. Once the handshake completes it settles
+         * as either the host name string, or `false` if SNI was not used.
+         * @since v0.11.3
+         */
+        servername: string | false | null;
         /**
          * The `tlsSocket.setKeyCert()` method sets the private key and certificate to use for the socket.
          * This is mainly useful if you wish to select a server certificate from a TLS server's `ALPNCallback`.
@@ -746,6 +758,7 @@ declare module "node:tls" {
         // #endregion
     }
     type SecureVersion = "TLSv1.3" | "TLSv1.2" | "TLSv1.1" | "TLSv1";
+    type CertificateCompressionAlgorithm = "zlib" | "brotli" | "zstd";
     interface SecureContextOptions {
         /**
          * If set, this will be called when a client opens a connection using the ALPN extension.
@@ -782,6 +795,15 @@ declare module "node:tls" {
          *  able to validate the certificate, and the handshake will fail.
          */
         cert?: string | Buffer | Array<string | Buffer> | undefined;
+        /**
+         * An array of supported certificate
+         * compression algorithm names, in preference order. Supported values are
+         * `'zlib'`, `'brotli'`, and `'zstd'`. When set, enables TLS certificate
+         * compression ([RFC 8879](https://tools.ietf.org/html/rfc8879)) which compresses certificates during the TLS
+         * handshake, reducing handshake size. Only effective with TLSv1.3.
+         * **Default:** `[]` (disabled).
+         */
+        certificateCompression?: readonly CertificateCompressionAlgorithm[] | undefined;
         /**
          *  Colon-separated list of supported signature algorithms. The list
          *  can contain digest algorithms (SHA256, MD5 etc.), public key
@@ -812,13 +834,16 @@ declare module "node:tls" {
          */
         dhparam?: string | Buffer | undefined;
         /**
-         * A string describing a named curve or a colon separated list of curve
-         * NIDs or names, for example P-521:P-384:P-256, to use for ECDH key
-         * agreement. Set to auto to select the curve automatically. Use
-         * crypto.getCurves() to obtain a list of available curve names. On
-         * recent releases, openssl ecparam -list_curves will also display the
-         * name and description of each available elliptic curve. Default:
-         * tls.DEFAULT_ECDH_CURVE.
+         * A string describing a named curve, TLS group, or
+         * colon-separated list of named curves or TLS groups to use for key agreement,
+         * for example `P-521:P-384:P-256`, `X25519`, or `X25519MLKEM768`. The
+         * historical name of this option refers to ECDH key agreement in TLSv1.2 and
+         * below. In TLSv1.3, this option configures the TLS Supported Groups and
+         * key share groups offered or accepted by the TLS stack. Set to `auto` to
+         * select the group automatically. Use `crypto.getCurves()` to obtain a
+         * list of available elliptic curve names. For TLS group names, use
+         * `openssl list -tls-groups` or consult the [IANA TLS Supported Groups
+         * registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8).
          */
         ecdhCurve?: string | undefined;
         /**
@@ -1110,6 +1135,20 @@ declare module "node:tls" {
      * @since v0.10.2
      */
     function getCiphers(): string[];
+    /**
+     * Returns an array with the names of the RFC 8879 certificate compression
+     * algorithms supported by the current OpenSSL build, suitable for use in the
+     * `certificateCompression` option of `tls.createSecureContext()`. Possible
+     * values include `'zlib'`, `'brotli'`, and `'zstd'`.
+     *
+     * The array is empty when certificate compression is unavailable.
+     *
+     * ```js
+     * console.log(tls.getCertificateCompressionAlgorithms()); // ['zlib', 'brotli', 'zstd']
+     * ```
+     * @since v26.4.0
+     */
+    function getCertificateCompressionAlgorithms(): CertificateCompressionAlgorithm[];
     /**
      * Sets the default CA certificates used by Node.js TLS clients. If the provided
      * certificates are parsed successfully, they will become the default CA
@@ -1143,9 +1182,9 @@ declare module "node:tls" {
      */
     function setDefaultCACertificates(certs: ReadonlyArray<string | NodeJS.ArrayBufferView>): void;
     /**
-     * The default curve name to use for ECDH key agreement in a tls server.
-     * The default value is `'auto'`. See `{@link createSecureContext()}` for further
-     * information.
+     * The default named curve or TLS group list to use for key agreement in a TLS
+     * server. The default value is `'auto'`. See `tls.createSecureContext()` for
+     * further information.
      * @since v0.11.13
      */
     let DEFAULT_ECDH_CURVE: string;

package/node_modules/@types/node/ts5.6/buffer.buffer.d.ts

@@ -459,4 +459,9 @@ declare module "node:buffer" {
          */
         type AllowSharedBuffer = Buffer;
     }
+    /**
+     * @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
+     * TypeScript versions earlier than 5.7.
+     */
+    type BufferView<T extends NodeJS.ArrayBufferView> = Buffer;
 }

package/node_modules/@types/node/ts5.6/index.d.ts

@@ -110,6 +110,7 @@
 /// <reference path="../util.d.ts" />
 /// <reference path="../util/types.d.ts" />
 /// <reference path="../v8.d.ts" />
+/// <reference path="../vfs.d.ts" />
 /// <reference path="../vm.d.ts" />
 /// <reference path="../wasi.d.ts" />
 /// <reference path="../worker_threads.d.ts" />

package/node_modules/@types/node/ts5.7/index.d.ts

@@ -110,6 +110,7 @@
 /// <reference path="../util.d.ts" />
 /// <reference path="../util/types.d.ts" />
 /// <reference path="../v8.d.ts" />
+/// <reference path="../vfs.d.ts" />
 /// <reference path="../vm.d.ts" />
 /// <reference path="../wasi.d.ts" />
 /// <reference path="../worker_threads.d.ts" />

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

@@ -28,10 +28,11 @@ declare module "node:tty" {
          * Allows configuration of `tty.ReadStream` so that it operates as a raw device.
          *
          * When in raw mode, input is always available character-by-character, not
-         * including modifiers. Additionally, all special processing of characters by the
-         * terminal is disabled, including echoing input
+         * including modifiers. Additionally, all special processing of input characters
+         * by the terminal is disabled, including echoing input
          * characters. Ctrl+C will no longer cause a `SIGINT` when
-         * in this mode.
+         * in this mode. This mode does not affect terminal output processing, such as
+         * newline translation on Unix terminals.
          * @since v0.7.7
          * @param mode If `true`, configures the `tty.ReadStream` to operate as a raw device. If `false`, configures the `tty.ReadStream` to operate in its default mode. The `readStream.isRaw`
          * property will be set to the resulting mode.

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

@@ -0,0 +1,211 @@
+declare module "node:vfs" {
+    /**
+     * Convenience factory equivalent to `new VirtualFileSystem(provider, options)`.
+     *
+     * ```js
+     * const vfs = require('node:vfs');
+     *
+     * // Default in-memory provider
+     * const memoryVfs = vfs.create();
+     *
+     * // Explicit provider
+     * const realVfs = vfs.create(new vfs.RealFSProvider('/tmp/sandbox'));
+     * ```
+     * @since v26.4.0
+     * @param provider The provider to use. **Default:** `new MemoryProvider()`.
+     */
+    function create(provider?: VirtualProvider, options?: VirtualFileSystemOptions): VirtualFileSystem;
+    function create(options: VirtualFileSystemOptions): VirtualFileSystem;
+    interface VirtualFileSystemOptions {
+        /**
+         * Whether to emit the experimental warning. **Default:** `true`.
+         */
+        emitExperimentalWarning?: boolean | undefined;
+    }
+    /**
+     * A `VirtualFileSystem` wraps a {@link VirtualProvider} and exposes a
+     * `node:fs`-like API. Each instance maintains its own file tree.
+     * @since v26.4.0
+     */
+    class VirtualFileSystem {
+        /**
+         * @param provider The provider to use. **Default:** `new MemoryProvider()`.
+         */
+        constructor(provider?: VirtualProvider, options?: VirtualFileSystemOptions);
+        constructor(options: VirtualFileSystemOptions);
+        /**
+         * The provider backing this VFS instance.
+         * @since v26.4.0
+         */
+        readonly provider: VirtualProvider;
+        /**
+         * `true` when the underlying provider is read-only.
+         * @since v26.4.0
+         */
+        readonly readonly: boolean;
+    }
+    interface VirtualFileSystem extends
+        // Synchronous API
+        Pick<
+            typeof import("node:fs"),
+            | "existsSync"
+            | "statSync"
+            | "lstatSync"
+            | "readFileSync"
+            | "writeFileSync"
+            | "appendFileSync"
+            | "readdirSync"
+            | "mkdirSync"
+            | "rmdirSync"
+            | "unlinkSync"
+            | "renameSync"
+            | "copyFileSync"
+            | "realpathSync"
+            | "readlinkSync"
+            | "symlinkSync"
+            | "accessSync"
+            | "rmSync"
+            | "truncateSync"
+            | "ftruncateSync"
+            | "linkSync"
+            | "chmodSync"
+            | "chownSync"
+            | "utimesSync"
+            | "lutimesSync"
+            | "mkdtempSync"
+            | "opendirSync"
+            | "openAsBlob"
+            | "openSync"
+            | "closeSync"
+            | "readSync"
+            | "writeSync"
+            | "fstatSync"
+            | "createReadStream"
+            | "createWriteStream"
+            | "watch"
+            | "watchFile"
+            | "unwatchFile"
+        >,
+        // Callback API
+        Pick<
+            typeof import("node:fs"),
+            | "readFile"
+            | "writeFile"
+            | "stat"
+            | "lstat"
+            | "readdir"
+            | "realpath"
+            | "readlink"
+            | "access"
+            | "open"
+            | "close"
+            | "read"
+            | "write"
+            | "rm"
+            | "fstat"
+            | "truncate"
+            | "ftruncate"
+            | "link"
+            | "mkdtemp"
+            | "opendir"
+        >
+    {
+        // Promise API
+        readonly promises: Pick<
+            typeof import("node:fs/promises"),
+            | "readFile"
+            | "writeFile"
+            | "appendFile"
+            | "stat"
+            | "lstat"
+            | "readdir"
+            | "mkdir"
+            | "rmdir"
+            | "unlink"
+            | "rename"
+            | "copyFile"
+            | "realpath"
+            | "readlink"
+            | "symlink"
+            | "access"
+            | "rm"
+            | "truncate"
+            | "link"
+            | "mkdtemp"
+            | "chmod"
+            | "chown"
+            | "lchown"
+            | "utimes"
+            | "lutimes"
+            | "open"
+            | "lchmod"
+            | "watch"
+        >;
+    }
+    /**
+     * The base class for all VFS providers. Subclasses implement the essential
+     * primitives (such as `open`, `stat`, `readdir`, `mkdir`, `rmdir`, `unlink`,
+     * `rename`, etc.) and inherit default implementations of the derived
+     * methods (such as `readFile`, `writeFile`, `exists`, `copyFile`, `access`, etc.).
+     * @since v26.4.0
+     */
+    abstract class VirtualProvider {
+        get readonly(): boolean;
+        get supportsSymlinks(): boolean;
+        get supportsWatch(): boolean;
+    }
+    /**
+     * The default in-memory provider. Stores files, directories, and symbolic
+     * links in a `Map`-backed tree, supports symlinks (`supportsSymlinks ===
+     * true`), and supports watching (`supportsWatch === true`).
+     * @since v26.4.0
+     */
+    class MemoryProvider extends VirtualProvider {
+        /**
+         * Locks the provider into read-only mode. Subsequent writes through any
+         * `VirtualFileSystem` using this provider throw `EROFS`. There is no
+         * way to revert the provider to writable.
+         *
+         * ```js
+         * const vfs = require('node:vfs');
+         *
+         * const provider = new vfs.MemoryProvider();
+         * const myVfs = vfs.create(provider);
+         * myVfs.writeFileSync('/seed.txt', 'initial');
+         *
+         * provider.setReadOnly();
+         *
+         * myVfs.writeFileSync('/x.txt', 'fail'); // throws EROFS
+         * ```
+         * @since v26.4.0
+         */
+        setReadOnly(): void;
+    }
+    /**
+     * A provider that wraps a directory (i.e. one on the actual file system) and
+     * exposes its contents through the VFS API. All VFS paths are resolved relative to
+     * the root and verified to stay inside it; symbolic links resolving outside the
+     * root are rejected. This path mapping is not a sandbox or access-control
+     * mechanism.
+     * @since v26.4.0
+     */
+    class RealFSProvider extends VirtualProvider {
+        /**
+         * ```js
+         * const vfs = require('node:vfs');
+         *
+         * const realVfs = vfs.create(new vfs.RealFSProvider('/tmp/vfs-root'));
+         * realVfs.writeFileSync('/file.txt', 'hello'); // writes /tmp/vfs-root/file.txt
+         * ```
+         * @since v26.4.0
+         * @param rootPath The absolute file-system path to use as the root.
+         * Must be a non-empty string.
+         */
+        constructor(rootPath: string);
+        /**
+         * The resolved absolute path used as the root.
+         * @since v26.4.0
+         */
+        readonly rootPath: string;
+    }
+}

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

@@ -741,7 +741,7 @@ 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
+         * Evaluate the module and its dependencies. 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;
@@ -886,6 +886,7 @@ declare module "node:vm" {
          * const module = new vm.SourceTextModule(
          *   'Object.getPrototypeOf(import.meta.prop).secret = secret;',
          *   {
+         *     context: contextifiedObject,
          *     initializeImportMeta(meta) {
          *       // Note: this object is created in the top context. As such,
          *       // Object.getPrototypeOf(import.meta.prop) points to the
@@ -904,7 +905,7 @@ declare module "node:vm" {
          * // To fix this problem, replace
          * //     meta.prop = {};
          * // above with
-         * //     meta.prop = vm.runInContext('{}', contextifiedObject);
+         * //     meta.prop = vm.runInContext('({})', contextifiedObject);
          * ```
          * @param code JavaScript Module code to parse
          */

package/node_modules/@types/node/web-globals/streams.d.ts

@@ -19,6 +19,8 @@ type _ReadableStreamDefaultController<R = any> = typeof globalThis extends { onm
     : webstreams.ReadableStreamDefaultController<R>;
 type _ReadableStreamDefaultReader<R = any> = typeof globalThis extends { onmessage: any } ? {}
     : webstreams.ReadableStreamDefaultReader<R>;
+type _ReadableWritablePair<R = any, W = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableWritablePair<R, W>;
 type _TextDecoderStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.TextDecoderStream;
 type _TextEncoderStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.TextEncoderStream;
 type _TransformStream<I = any, O = any> = typeof globalThis extends { onmessage: any } ? {}
@@ -82,6 +84,8 @@ declare global {
         ? T
         : typeof webstreams.ReadableStreamDefaultReader;
 
+    interface ReadableWritablePair<R = any, W = any> extends _ReadableWritablePair<R, W> {}
+
     interface TextDecoderStream extends _TextDecoderStream {}
     var TextDecoderStream: typeof globalThis extends { onmessage: any; TextDecoderStream: infer T } ? T
         : typeof webstreams.TextDecoderStream;

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

@@ -6,6 +6,7 @@ declare module "node:worker_threads" {
         NodeEventTarget,
     } from "node:events";
     import { FileHandle } from "node:fs/promises";
+    import { Server, Socket } from "node:net";
     import { Performance } from "node:perf_hooks";
     import { Readable, Writable } from "node:stream";
     import { ReadableStream, TransformStream, WritableStream } from "node:stream/web";
@@ -514,7 +515,9 @@ declare module "node:worker_threads" {
         | FileHandle
         | ReadableStream
         | WritableStream
-        | TransformStream;
+        | TransformStream
+        | Server
+        | Socket;
     interface LockGrantedCallback<T> {
         (lock: Lock | null): T;
     }