cloudstructs 0.9.32 → 0.9.34

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

@@ -76,7 +76,7 @@
  *
  * If any tests fail, the process exit code is set to `1`.
  * @since v18.0.0, v16.17.0
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/test.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/test.js)
  */
 declare module "node:test" {
     import { Readable } from "node:stream";
@@ -320,9 +320,17 @@ declare module "node:test" {
          * @default false
          */
         concurrency?: number | boolean | undefined;
+        /**
+         * Specifies the current working directory to be used by the test runner.
+         * Serves as the base path for resolving files according to the
+         * [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
+         * @since v23.0.0
+         * @default process.cwd()
+         */
+        cwd?: string | undefined;
         /**
          * An array containing the list of files to run. If omitted, files are run according to the
-         * [test runner execution model](https://nodejs.org/docs/latest-v22.x/api/test.html#test-runner-execution-model).
+         * [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
          */
         files?: readonly string[] | undefined;
         /**
@@ -335,7 +343,7 @@ declare module "node:test" {
         /**
          * An array containing the list of glob patterns to match test files.
          * This option cannot be used together with `files`. If omitted, files are run according to the
-         * [test runner execution model](https://nodejs.org/docs/latest-v22.x/api/test.html#test-runner-execution-model).
+         * [test runner execution model](https://nodejs.org/docs/latest-v24.x/api/test.html#test-runner-execution-model).
          * @since v22.6.0
          */
         globPatterns?: readonly string[] | undefined;
@@ -416,7 +424,7 @@ declare module "node:test" {
          */
         shard?: TestShard | undefined;
         /**
-         * enable [code coverage](https://nodejs.org/docs/latest-v22.x/api/test.html#collecting-code-coverage) collection.
+         * enable [code coverage](https://nodejs.org/docs/latest-v24.x/api/test.html#collecting-code-coverage) collection.
          * @since v22.10.0
          * @default false
          */
@@ -648,11 +656,12 @@ declare module "node:test" {
          */
         readonly name: string;
         /**
-         * Used to set the number of assertions and subtests that are expected to run within the test.
-         * If the number of assertions and subtests that run does not match the expected count, the test will fail.
+         * This function is used to set the number of assertions and subtests that are expected to run
+         * within the test. If the number of assertions and subtests that run does not match the
+         * expected count, the test will fail.
+         *
+         * > Note: To make sure assertions are tracked, `t.assert` must be used instead of `assert` directly.
          *
-         * To make sure assertions are tracked, the assert functions on `context.assert` must be used,
-         * instead of importing from the `node:assert` module.
          * ```js
          * test('top level test', (t) => {
          *   t.plan(2);
@@ -661,7 +670,9 @@ declare module "node:test" {
          * });
          * ```
          *
-         * When working with asynchronous code, the `plan` function can be used to ensure that the correct number of assertions are run:
+         * When working with asynchronous code, the `plan` function can be used to ensure that the
+         * correct number of assertions are run:
+         *
          * ```js
          * test('planning with streams', (t, done) => {
          *   function* generate() {
@@ -675,14 +686,35 @@ declare module "node:test" {
          *   stream.on('data', (chunk) => {
          *     t.assert.strictEqual(chunk, expected.shift());
          *   });
+         *
          *   stream.on('end', () => {
          *     done();
          *   });
          * });
          * ```
+         *
+         * When using the `wait` option, you can control how long the test will wait for the expected assertions.
+         * For example, setting a maximum wait time ensures that the test will wait for asynchronous assertions
+         * to complete within the specified timeframe:
+         *
+         * ```js
+         * test('plan with wait: 2000 waits for async assertions', (t) => {
+         *   t.plan(1, { wait: 2000 }); // Waits for up to 2 seconds for the assertion to complete.
+         *
+         *   const asyncActivity = () => {
+         *     setTimeout(() => {
+         *          *       t.assert.ok(true, 'Async assertion completed within the wait time');
+         *     }, 1000); // Completes after 1 second, within the 2-second wait time.
+         *   };
+         *
+         *   asyncActivity(); // The test will pass because the assertion is completed in time.
+         * });
+         * ```
+         *
+         * Note: If a `wait` timeout is specified, it begins counting down only after the test function finishes executing.
          * @since v22.2.0
          */
-        plan(count: number): void;
+        plan(count: number, options?: TestContextPlanOptions): void;
         /**
          * If `shouldRunOnlyTests` is truthy, the test context will only run tests that
          * have the `only` option set. Otherwise, all tests are run. If Node.js was not
@@ -813,7 +845,7 @@ declare module "node:test" {
          * highlighting.
          * @since v22.14.0
          * @param value A value to serialize to a string. If Node.js was started with
-         * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--test-update-snapshots)
+         * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--test-update-snapshots)
          * flag, the serialized value is written to
          * `path`. Otherwise, the serialized value is compared to the contents of the
          * existing snapshot file.
@@ -836,7 +868,7 @@ declare module "node:test" {
          * ```
          * @since v22.3.0
          * @param value A value to serialize to a string. If Node.js was started with
-         * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--test-update-snapshots)
+         * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--test-update-snapshots)
          * flag, the serialized value is written to
          * the snapshot file. Otherwise, the serialized value is compared to the
          * corresponding value in the existing snapshot file.
@@ -858,6 +890,20 @@ declare module "node:test" {
          */
         serializers?: ReadonlyArray<(value: any) => any> | undefined;
     }
+    interface TestContextPlanOptions {
+        /**
+         * The wait time for the plan:
+         * * If `true`, the plan waits indefinitely for all assertions and subtests to run.
+         * * If `false`, the plan performs an immediate check after the test function completes,
+         * without waiting for any pending assertions or subtests.
+         * Any assertions or subtests that complete after this check will not be counted towards the plan.
+         * * If a number, it specifies the maximum wait time in milliseconds
+         * before timing out while waiting for expected assertions and subtests to be matched.
+         * If the timeout is reached, the test will fail.
+         * @default false
+         */
+        wait?: boolean | number | undefined;
+    }
     interface TestContextWaitForOptions {
         /**
          * The number of milliseconds to wait after an unsuccessful
@@ -1254,10 +1300,43 @@ declare module "node:test" {
         ): Mock<((value: MockedObject[MethodName]) => void) | Implementation>;
 
         /**
-         * This function is used to mock the exports of ECMAScript modules, CommonJS modules, and Node.js builtin modules.
-         * Any references to the original module prior to mocking are not impacted.
+         * This function is used to mock the exports of ECMAScript modules, CommonJS modules, JSON modules, and
+         * Node.js builtin modules. Any references to the original module prior to mocking are not impacted. In
+         * order to enable module mocking, Node.js must be started with the
+         * [`--experimental-test-module-mocks`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--experimental-test-module-mocks)
+         * command-line flag.
+         *
+         * The following example demonstrates how a mock is created for a module.
+         *
+         * ```js
+         * test('mocks a builtin module in both module systems', async (t) => {
+         *   // Create a mock of 'node:readline' with a named export named 'fn', which
+         *   // does not exist in the original 'node:readline' module.
+         *   const mock = t.mock.module('node:readline', {
+         *     namedExports: { fn() { return 42; } },
+         *   });
+         *
+         *   let esmImpl = await import('node:readline');
+         *   let cjsImpl = require('node:readline');
+         *
+         *   // cursorTo() is an export of the original 'node:readline' module.
+         *   assert.strictEqual(esmImpl.cursorTo, undefined);
+         *   assert.strictEqual(cjsImpl.cursorTo, undefined);
+         *   assert.strictEqual(esmImpl.fn(), 42);
+         *   assert.strictEqual(cjsImpl.fn(), 42);
+         *
+         *   mock.restore();
          *
-         * Only available through the [--experimental-test-module-mocks](https://nodejs.org/api/cli.html#--experimental-test-module-mocks) flag.
+         *   // The mock is restored, so the original builtin module is returned.
+         *   esmImpl = await import('node:readline');
+         *   cjsImpl = require('node:readline');
+         *
+         *   assert.strictEqual(typeof esmImpl.cursorTo, 'function');
+         *   assert.strictEqual(typeof cjsImpl.cursorTo, 'function');
+         *   assert.strictEqual(esmImpl.fn, undefined);
+         *   assert.strictEqual(cjsImpl.fn, undefined);
+         * });
+         * ```
          * @since v22.3.0
          * @experimental
          * @param specifier A string identifying the module to mock.
@@ -1452,7 +1531,6 @@ declare module "node:test" {
      * The `MockTracker` provides a top-level `timers` export
      * which is a `MockTimers` instance.
      * @since v20.4.0
-     * @experimental
      */
     class MockTimers {
         /**
@@ -1971,6 +2049,11 @@ interface TestDequeue extends TestLocationInfo {
      * The nesting level of the test.
      */
     nesting: number;
+    /**
+     * The test type. Either `'suite'` or `'test'`.
+     * @since v22.15.0
+     */
+    type: "suite" | "test";
 }
 interface TestEnqueue extends TestLocationInfo {
     /**
@@ -1981,6 +2064,11 @@ interface TestEnqueue extends TestLocationInfo {
      * The nesting level of the test.
      */
     nesting: number;
+    /**
+     * The test type. Either `'suite'` or `'test'`.
+     * @since v22.15.0
+     */
+    type: "suite" | "test";
 }
 interface TestFail extends TestLocationInfo {
     /**
@@ -2165,7 +2253,7 @@ interface TestSummary {
  * import test from 'node:test/reporters';
  * ```
  * @since v19.9.0
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/test/reporters.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/test/reporters.js)
  */
 declare module "node:test/reporters" {
     import { Transform, TransformOptions } from "node:stream";
@@ -2221,12 +2309,10 @@ declare module "node:test/reporters" {
     }
     /**
      * The `lcov` reporter outputs test coverage when used with the
-     * [`--experimental-test-coverage`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--experimental-test-coverage) flag.
+     * [`--experimental-test-coverage`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--experimental-test-coverage) flag.
      * @since v22.0.0
      */
-    // TODO: change the export to a wrapper function once node@0db38f0 is merged (breaking change)
-    // const lcov: ReporterConstructorWrapper<typeof LcovReporter>;
-    const lcov: LcovReporter;
+    const lcov: ReporterConstructorWrapper<typeof LcovReporter>;
 
     export { dot, junit, lcov, spec, tap, TestEvent };
 }

package/node_modules/@types/responselike/node_modules/@types/node/timers/promises.d.ts

@@ -11,7 +11,7 @@
  * } from 'node:timers/promises';
  * ```
  * @since v15.0.0
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/timers/promises.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/timers/promises.js)
  */
 declare module "timers/promises" {
     import { TimerOptions } from "node:timers";

package/node_modules/@types/responselike/node_modules/@types/node/timers.d.ts

@@ -6,7 +6,7 @@
  * The timer functions within Node.js implement a similar API as the timers API
  * provided by Web Browsers but use a different internal implementation that is
  * built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/timers.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/timers.js)
  */
 declare module "timers" {
     import { Abortable } from "node:events";

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

@@ -6,7 +6,7 @@
  * ```js
  * import tls from 'node:tls';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/tls.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/tls.js)
  */
 declare module "tls" {
     import { X509Certificate } from "node:crypto";
@@ -398,6 +398,14 @@ declare module "tls" {
             },
             callback: (err: Error | null) => void,
         ): undefined | boolean;
+        /**
+         * 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`.
+         * @since v22.5.0, v20.17.0
+         * @param context An object containing at least `key` and `cert` properties from the {@link createSecureContext()} `options`,
+         * or a TLS context object created with {@link createSecureContext()} itself.
+         */
+        setKeyCert(context: SecureContextOptions | SecureContext): void;
         /**
          * The `tlsSocket.setMaxSendFragment()` method sets the maximum TLS fragment size.
          * Returns `true` if setting the limit succeeded; `false` otherwise.
@@ -639,7 +647,7 @@ declare module "tls" {
          * @param context An object containing any of the possible properties from the {@link createSecureContext} `options` arguments (e.g. `key`, `cert`, `ca`, etc), or a TLS context object created
          * with {@link createSecureContext} itself.
          */
-        addContext(hostname: string, context: SecureContextOptions): void;
+        addContext(hostname: string, context: SecureContextOptions | SecureContext): void;
         /**
          * Returns the session ticket keys.
          *
@@ -789,13 +797,6 @@ declare module "tls" {
         prependOnceListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
         prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
     }
-    /**
-     * @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
-     */
-    interface SecurePair {
-        encrypted: TLSSocket;
-        cleartext: TLSSocket;
-    }
     type SecureVersion = "TLSv1.3" | "TLSv1.2" | "TLSv1.1" | "TLSv1";
     interface SecureContextOptions {
         /**
@@ -1094,45 +1095,6 @@ declare module "tls" {
         secureConnectListener?: () => void,
     ): TLSSocket;
     function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
-    /**
-     * Creates a new secure pair object with two streams, one of which reads and writes
-     * the encrypted data and the other of which reads and writes the cleartext data.
-     * Generally, the encrypted stream is piped to/from an incoming encrypted data
-     * stream and the cleartext one is used as a replacement for the initial encrypted
-     * stream.
-     *
-     * `tls.createSecurePair()` returns a `tls.SecurePair` object with `cleartext` and `encrypted` stream properties.
-     *
-     * Using `cleartext` has the same API as {@link TLSSocket}.
-     *
-     * The `tls.createSecurePair()` method is now deprecated in favor of`tls.TLSSocket()`. For example, the code:
-     *
-     * ```js
-     * pair = tls.createSecurePair(// ... );
-     * pair.encrypted.pipe(socket);
-     * socket.pipe(pair.encrypted);
-     * ```
-     *
-     * can be replaced by:
-     *
-     * ```js
-     * secureSocket = tls.TLSSocket(socket, options);
-     * ```
-     *
-     * where `secureSocket` has the same API as `pair.cleartext`.
-     * @since v0.3.2
-     * @deprecated Since v0.11.3 - Use {@link TLSSocket} instead.
-     * @param context A secure context object as returned by `tls.createSecureContext()`
-     * @param isServer `true` to specify that this TLS connection should be opened as a server.
-     * @param requestCert `true` to specify whether a server should request a certificate from a connecting client. Only applies when `isServer` is `true`.
-     * @param rejectUnauthorized If not `false` a server automatically reject clients with invalid certificates. Only applies when `isServer` is `true`.
-     */
-    function createSecurePair(
-        context?: SecureContext,
-        isServer?: boolean,
-        requestCert?: boolean,
-        rejectUnauthorized?: boolean,
-    ): SecurePair;
     /**
      * `{@link createServer}` sets the default value of the `honorCipherOrder` option
      * to `true`, other APIs that create secure contexts leave it unset.
@@ -1158,13 +1120,38 @@ declare module "tls" {
      * @since v0.11.13
      */
     function createSecureContext(options?: SecureContextOptions): SecureContext;
+    /**
+     * Returns an array containing the CA certificates from various sources, depending on `type`:
+     *
+     * * `"default"`: return the CA certificates that will be used by the Node.js TLS clients by default.
+     *   * When `--use-bundled-ca` is enabled (default), or `--use-openssl-ca` is not enabled,
+     *     this would include CA certificates from the bundled Mozilla CA store.
+     *   * When `--use-system-ca` is enabled, this would also include certificates from the system's
+     *     trusted store.
+     *   * When `NODE_EXTRA_CA_CERTS` is used, this would also include certificates loaded from the specified
+     *     file.
+     * * `"system"`: return the CA certificates that are loaded from the system's trusted store, according
+     *   to rules set by `--use-system-ca`. This can be used to get the certificates from the system
+     *   when `--use-system-ca` is not enabled.
+     * * `"bundled"`: return the CA certificates from the bundled Mozilla CA store. This would be the same
+     *   as `tls.rootCertificates`.
+     * * `"extra"`: return the CA certificates loaded from `NODE_EXTRA_CA_CERTS`. It's an empty array if
+     *   `NODE_EXTRA_CA_CERTS` is not set.
+     * @since v22.15.0
+     * @param type The type of CA certificates that will be returned. Valid values
+     * are `"default"`, `"system"`, `"bundled"` and `"extra"`.
+     * **Default:** `"default"`.
+     * @returns An array of PEM-encoded certificates. The array may contain duplicates
+     * if the same certificate is repeatedly stored in multiple sources.
+     */
+    function getCACertificates(type?: "default" | "system" | "bundled" | "extra"): string[];
     /**
      * Returns an array with the names of the supported TLS ciphers. The names are
      * lower-case for historical reasons, but must be uppercased to be used in
      * the `ciphers` option of `{@link createSecureContext}`.
      *
      * Not all supported ciphers are enabled by default. See
-     * [Modifying the default TLS cipher suite](https://nodejs.org/docs/latest-v22.x/api/tls.html#modifying-the-default-tls-cipher-suite).
+     * [Modifying the default TLS cipher suite](https://nodejs.org/docs/latest-v24.x/api/tls.html#modifying-the-default-tls-cipher-suite).
      *
      * Cipher names that start with `'tls_'` are for TLSv1.3, all the others are for
      * TLSv1.2 and below.

package/node_modules/@types/responselike/node_modules/@types/node/trace_events.d.ts

@@ -9,8 +9,8 @@
  * The available categories are:
  *
  * * `node`: An empty placeholder.
- * * `node.async_hooks`: Enables capture of detailed [`async_hooks`](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html) trace data.
- * The [`async_hooks`](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html) events have a unique `asyncId` and a special `triggerId` `triggerAsyncId` property.
+ * * `node.async_hooks`: Enables capture of detailed [`async_hooks`](https://nodejs.org/docs/latest-v24.x/api/async_hooks.html) trace data.
+ * The [`async_hooks`](https://nodejs.org/docs/latest-v24.x/api/async_hooks.html) events have a unique `asyncId` and a special `triggerId` `triggerAsyncId` property.
  * * `node.bootstrap`: Enables capture of Node.js bootstrap milestones.
  * * `node.console`: Enables capture of `console.time()` and `console.count()` output.
  * * `node.threadpoolwork.sync`: Enables capture of trace data for threadpool synchronous operations, such as `blob`, `zlib`, `crypto` and `node_api`.
@@ -22,7 +22,7 @@
  * * `node.fs_dir.sync`: Enables capture of trace data for file system sync directory methods.
  * * `node.fs.async`: Enables capture of trace data for file system async methods.
  * * `node.fs_dir.async`: Enables capture of trace data for file system async directory methods.
- * * `node.perf`: Enables capture of [Performance API](https://nodejs.org/docs/latest-v22.x/api/perf_hooks.html) measurements.
+ * * `node.perf`: Enables capture of [Performance API](https://nodejs.org/docs/latest-v24.x/api/perf_hooks.html) measurements.
  *    * `node.perf.usertiming`: Enables capture of only Performance API User Timing
  *    measures and marks.
  *    * `node.perf.timerify`: Enables capture of only Performance API timerify
@@ -30,7 +30,7 @@
  * * `node.promises.rejections`: Enables capture of trace data tracking the number
  * of unhandled Promise rejections and handled-after-rejections.
  * * `node.vm.script`: Enables capture of trace data for the `node:vm` module's `runInNewContext()`, `runInContext()`, and `runInThisContext()` methods.
- * * `v8`: The [V8](https://nodejs.org/docs/latest-v22.x/api/v8.html) events are GC, compiling, and execution related.
+ * * `v8`: The [V8](https://nodejs.org/docs/latest-v24.x/api/v8.html) events are GC, compiling, and execution related.
  * * `node.http`: Enables capture of trace data for http request / response.
  *
  * By default the `node`, `node.async_hooks`, and `v8` categories are enabled.
@@ -88,9 +88,9 @@
  * However the trace-event timestamps are expressed in microseconds,
  * unlike `process.hrtime()` which returns nanoseconds.
  *
- * The features from this module are not available in [`Worker`](https://nodejs.org/docs/latest-v22.x/api/worker_threads.html#class-worker) threads.
+ * The features from this module are not available in [`Worker`](https://nodejs.org/docs/latest-v24.x/api/worker_threads.html#class-worker) threads.
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/trace_events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/trace_events.js)
  */
 declare module "trace_events" {
     /**

package/node_modules/@types/responselike/node_modules/@types/node/ts5.1/compatibility/disposable.d.ts

@@ -0,0 +1,12 @@
+interface SymbolConstructor {
+    readonly dispose: unique symbol;
+    readonly asyncDispose: unique symbol;
+}
+
+interface Disposable {
+    [Symbol.dispose](): void;
+}
+
+interface AsyncDisposable {
+    [Symbol.asyncDispose](): PromiseLike<void>;
+}

package/node_modules/@types/responselike/node_modules/@types/node/ts5.1/index.d.ts

@@ -0,0 +1,98 @@
+/**
+ * License for programmatically and manually incorporated
+ * documentation aka. `JSDoc` from https://github.com/nodejs/node/tree/master/doc
+ *
+ * Copyright Node.js contributors. All rights reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+// NOTE: These definitions support Node.js and TypeScript 5.1.
+
+// Reference required TypeScript libraries:
+/// <reference lib="es2020" />
+
+// TypeScript library polyfills required for TypeScript <=5.1:
+/// <reference path="./compatibility/disposable.d.ts" />
+
+// TypeScript library polyfills required for TypeScript <=5.6:
+/// <reference path="../ts5.6/compatibility/float16array.d.ts" />
+
+// Iterator definitions required for compatibility with TypeScript <5.6:
+/// <reference path="../compatibility/iterators.d.ts" />
+
+// Definitions for Node.js modules specific to TypeScript <=5.6:
+/// <reference path="../ts5.6/globals.typedarray.d.ts" />
+/// <reference path="../ts5.6/buffer.buffer.d.ts" />
+
+// Definitions for Node.js modules that are not specific to any version of TypeScript:
+/// <reference path="../globals.d.ts" />
+/// <reference path="../assert.d.ts" />
+/// <reference path="../assert/strict.d.ts" />
+/// <reference path="../async_hooks.d.ts" />
+/// <reference path="../buffer.d.ts" />
+/// <reference path="../child_process.d.ts" />
+/// <reference path="../cluster.d.ts" />
+/// <reference path="../console.d.ts" />
+/// <reference path="../constants.d.ts" />
+/// <reference path="../crypto.d.ts" />
+/// <reference path="../dgram.d.ts" />
+/// <reference path="../diagnostics_channel.d.ts" />
+/// <reference path="../dns.d.ts" />
+/// <reference path="../dns/promises.d.ts" />
+/// <reference path="../dns/promises.d.ts" />
+/// <reference path="../domain.d.ts" />
+/// <reference path="../dom-events.d.ts" />
+/// <reference path="../events.d.ts" />
+/// <reference path="../fs.d.ts" />
+/// <reference path="../fs/promises.d.ts" />
+/// <reference path="../http.d.ts" />
+/// <reference path="../http2.d.ts" />
+/// <reference path="../https.d.ts" />
+/// <reference path="../inspector.d.ts" />
+/// <reference path="../module.d.ts" />
+/// <reference path="../net.d.ts" />
+/// <reference path="../os.d.ts" />
+/// <reference path="../path.d.ts" />
+/// <reference path="../perf_hooks.d.ts" />
+/// <reference path="../process.d.ts" />
+/// <reference path="../punycode.d.ts" />
+/// <reference path="../querystring.d.ts" />
+/// <reference path="../readline.d.ts" />
+/// <reference path="../readline/promises.d.ts" />
+/// <reference path="../repl.d.ts" />
+/// <reference path="../sea.d.ts" />
+/// <reference path="../sqlite.d.ts" />
+/// <reference path="../stream.d.ts" />
+/// <reference path="../stream/promises.d.ts" />
+/// <reference path="../stream/consumers.d.ts" />
+/// <reference path="../stream/web.d.ts" />
+/// <reference path="../string_decoder.d.ts" />
+/// <reference path="../test.d.ts" />
+/// <reference path="../timers.d.ts" />
+/// <reference path="../timers/promises.d.ts" />
+/// <reference path="../tls.d.ts" />
+/// <reference path="../trace_events.d.ts" />
+/// <reference path="../tty.d.ts" />
+/// <reference path="../url.d.ts" />
+/// <reference path="../util.d.ts" />
+/// <reference path="../v8.d.ts" />
+/// <reference path="../vm.d.ts" />
+/// <reference path="../wasi.d.ts" />
+/// <reference path="../worker_threads.d.ts" />
+/// <reference path="../zlib.d.ts" />

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

@@ -158,6 +158,7 @@ declare module "buffer" {
              * @param encoding The encoding of `string`. **Default:** `'utf8'`.
              */
             from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer;
+            from(arrayOrString: WithImplicitCoercion<ArrayLike<number> | string>): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
              * @param values to create a new Buffer
@@ -447,6 +448,8 @@ declare module "buffer" {
              */
             subarray(start?: number, end?: number): Buffer;
         }
+        type NonSharedBuffer = Buffer;
+        type AllowSharedBuffer = Buffer;
     }
     /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
     var SlowBuffer: {

package/node_modules/@types/responselike/node_modules/@types/node/ts5.6/compatibility/float16array.d.ts

@@ -0,0 +1,71 @@
+// Interface declaration for Float16Array, required in @types/node v24+.
+// These definitions are specific to TS <=5.6.
+
+// This needs all of the "common" properties/methods of the TypedArrays,
+// otherwise the type unions `TypedArray` and `ArrayBufferView` will be
+// empty objects.
+interface Float16Array extends Pick<Float32Array, typeof Symbol.iterator | "entries" | "keys" | "values"> {
+    readonly BYTES_PER_ELEMENT: number;
+    readonly buffer: ArrayBufferLike;
+    readonly byteLength: number;
+    readonly byteOffset: number;
+    readonly length: number;
+    readonly [Symbol.toStringTag]: "Float16Array";
+    at(index: number): number | undefined;
+    copyWithin(target: number, start: number, end?: number): this;
+    every(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): boolean;
+    fill(value: number, start?: number, end?: number): this;
+    filter(predicate: (value: number, index: number, array: Float16Array) => any, thisArg?: any): Float16Array;
+    find(predicate: (value: number, index: number, obj: Float16Array) => boolean, thisArg?: any): number | undefined;
+    findIndex(predicate: (value: number, index: number, obj: Float16Array) => boolean, thisArg?: any): number;
+    findLast<S extends number>(
+        predicate: (value: number, index: number, array: Float16Array) => value is S,
+        thisArg?: any,
+    ): S | undefined;
+    findLast(
+        predicate: (value: number, index: number, array: Float16Array) => unknown,
+        thisArg?: any,
+    ): number | undefined;
+    findLastIndex(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): number;
+    forEach(callbackfn: (value: number, index: number, array: Float16Array) => void, thisArg?: any): void;
+    includes(searchElement: number, fromIndex?: number): boolean;
+    indexOf(searchElement: number, fromIndex?: number): number;
+    join(separator?: string): string;
+    lastIndexOf(searchElement: number, fromIndex?: number): number;
+    map(callbackfn: (value: number, index: number, array: Float16Array) => number, thisArg?: any): Float16Array;
+    reduce(
+        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
+    ): number;
+    reduce(
+        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
+        initialValue: number,
+    ): number;
+    reduce<U>(
+        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float16Array) => U,
+        initialValue: U,
+    ): U;
+    reduceRight(
+        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
+    ): number;
+    reduceRight(
+        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
+        initialValue: number,
+    ): number;
+    reduceRight<U>(
+        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float16Array) => U,
+        initialValue: U,
+    ): U;
+    reverse(): Float16Array;
+    set(array: ArrayLike<number>, offset?: number): void;
+    slice(start?: number, end?: number): Float16Array;
+    some(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): boolean;
+    sort(compareFn?: (a: number, b: number) => number): this;
+    subarray(begin?: number, end?: number): Float16Array;
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+    toReversed(): Float16Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Float16Array;
+    toString(): string;
+    valueOf(): Float16Array;
+    with(index: number, value: number): Float16Array;
+    [index: number]: number;
+}

package/node_modules/@types/responselike/node_modules/@types/node/ts5.6/globals.typedarray.d.ts

@@ -12,6 +12,7 @@ declare global {
             | Int32Array
             | BigUint64Array
             | BigInt64Array
+            | Float16Array
             | Float32Array
             | Float64Array;
         type ArrayBufferView = TypedArray | DataView;