cloudstructs 0.5.5 → 0.5.6

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

@@ -41,7 +41,7 @@
  * // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
  * const buf7 = Buffer.from('tést', 'latin1');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/buffer.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/buffer.js)
  */
 declare module 'buffer' {
     import { BinaryLike } from 'node:crypto';
@@ -114,7 +114,6 @@ declare module 'buffer' {
      * A [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) encapsulates immutable, raw data that can be safely shared across
      * multiple worker threads.
      * @since v15.7.0, v14.18.0
-     * @experimental
      */
     export class Blob {
         /**
@@ -763,8 +762,6 @@ declare module 'buffer' {
              * Returns a new `Buffer` that references the same memory as the original, but
              * offset and cropped by the `start` and `end` indices.
              *
-             * This is the same behavior as `buf.subarray()`.
-             *
              * This method is not compatible with the `Uint8Array.prototype.slice()`,
              * which is a superclass of `Buffer`. To copy the slice, use`Uint8Array.prototype.slice()`.
              *
@@ -780,8 +777,17 @@ declare module 'buffer' {
              *
              * console.log(buf.toString());
              * // Prints: buffer
+             *
+             * // With buf.slice(), the original buffer is modified.
+             * const notReallyCopiedBuf = buf.slice();
+             * notReallyCopiedBuf[0]++;
+             * console.log(notReallyCopiedBuf.toString());
+             * // Prints: cuffer
+             * console.log(buf.toString());
+             * // Also prints: cuffer (!)
              * ```
              * @since v0.3.0
+             * @deprecated Use `subarray` instead.
              * @param [start=0] Where the new `Buffer` will start.
              * @param [end=buf.length] Where the new `Buffer` will end (not inclusive).
              */
@@ -1948,7 +1954,7 @@ declare module 'buffer' {
              *
              * * a string, `value` is interpreted according to the character encoding in`encoding`.
              * * a `Buffer` or [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), `value` will be used in its entirety.
-             * To compare a partial `Buffer`, use `buf.slice()`.
+             * To compare a partial `Buffer`, use `buf.subarray`.
              * * a number, `value` will be interpreted as an unsigned 8-bit integer
              * value between `0` and `255`.
              *

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

@@ -28,8 +28,11 @@
  * identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }`option if the output will not be consumed.
  *
  * The command lookup is performed using the `options.env.PATH` environment
- * variable if it is in the `options` object. Otherwise, `process.env.PATH` is
- * used.
+ * variable if `env` is in the `options` object. Otherwise, `process.env.PATH` is
+ * used. If `options.env` is set without `PATH`, lookup on Unix is performed
+ * on a default search path search of `/usr/bin:/bin` (see your operating system's
+ * manual for execvpe/execvp), on Windows the current processes environment
+ * variable `PATH` is used.
  *
  * On Windows, environment variables are case-insensitive. Node.js
  * lexicographically sorts the `env` keys and uses the first one that
@@ -60,7 +63,7 @@
  * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
  * the synchronous methods can have significant impact on performance due to
  * stalling the event loop while spawned processes complete.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/child_process.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/child_process.js)
  */
 declare module 'child_process' {
     import { ObjectEncodingOptions } from 'node:fs';

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

@@ -1,7 +1,8 @@
 /**
- * A single instance of Node.js runs in a single thread. To take advantage of
- * multi-core systems, the user will sometimes want to launch a cluster of Node.js
- * processes to handle the load.
+ * Clusters of Node.js processes can be used to run multiple instances of Node.js
+ * that can distribute workloads among their application threads. When process
+ * isolation is not needed, use the `worker_threads` module instead, which
+ * allows running multiple application threads within a single Node.js instance.
  *
  * The cluster module allows easy creation of child processes that all share
  * server ports.
@@ -49,7 +50,7 @@
  * ```
  *
  * On Windows, it is not yet possible to set up a named pipe server in a worker.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/cluster.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/cluster.js)
  */
 declare module 'cluster' {
     import * as child from 'node:child_process';
@@ -99,9 +100,9 @@ declare module 'cluster' {
         /**
          * Send a message to a worker or primary, optionally with a handle.
          *
-         * In the primary this sends a message to a specific worker. It is identical to `ChildProcess.send()`.
+         * In the primary, this sends a message to a specific worker. It is identical to `ChildProcess.send()`.
          *
-         * In a worker this sends a message to the primary. It is identical to`process.send()`.
+         * In a worker, this sends a message to the primary. It is identical to`process.send()`.
          *
          * This example will echo back all messages from the primary:
          *
@@ -123,19 +124,13 @@ declare module 'cluster' {
         send(message: child.Serializable, sendHandle: child.SendHandle, callback?: (error: Error | null) => void): boolean;
         send(message: child.Serializable, sendHandle: child.SendHandle, options?: child.MessageOptions, callback?: (error: Error | null) => void): boolean;
         /**
-         * This function will kill the worker. In the primary, it does this
-         * by disconnecting the `worker.process`, and once disconnected, killing
-         * with `signal`. In the worker, it does it by disconnecting the channel,
-         * and then exiting with code `0`.
+         * This function will kill the worker. In the primary worker, it does this by
+         * disconnecting the `worker.process`, and once disconnected, killing with`signal`. In the worker, it does it by killing the process with `signal`.
          *
-         * Because `kill()` attempts to gracefully disconnect the worker process, it is
-         * susceptible to waiting indefinitely for the disconnect to complete. For example,
-         * if the worker enters an infinite loop, a graceful disconnect will never occur.
-         * If the graceful disconnect behavior is not needed, use `worker.process.kill()`.
+         * The `kill()` function kills the worker process without waiting for a graceful
+         * disconnect, it has the same behavior as `worker.process.kill()`.
          *
-         * Causes `.exitedAfterDisconnect` to be set.
-         *
-         * This method is aliased as `worker.destroy()` for backward compatibility.
+         * This method is aliased as `worker.destroy()` for backwards compatibility.
          *
          * In a worker, `process.kill()` exists, but it is not this function;
          * it is `kill()`.
@@ -253,7 +248,8 @@ declare module 'cluster' {
          */
         isDead(): boolean;
         /**
-         * This property is `true` if the worker exited due to `.kill()` or`.disconnect()`. If the worker exited any other way, it is `false`. If the
+         * This property is `true` if the worker exited due to `.disconnect()`.
+         * If the worker exited any other way, it is `false`. If the
          * worker has not exited, it is `undefined`.
          *
          * The boolean `worker.exitedAfterDisconnect` allows distinguishing between

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

@@ -53,7 +53,7 @@
  * myConsole.warn(`Danger ${name}! Danger!`);
  * // Prints: Danger Will Robinson! Danger!, to err
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/console.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/console.js)
  */
 declare module 'console' {
     import console = require('node:console');