@psnext/slingcli 3.1.20260904-1 → 3.3.20260911-1

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

@@ -1,4 +1,20 @@
-declare module "node:async_hooks" {
+/**
+ * We strongly discourage the use of the `async_hooks` API.
+ * Other APIs that can cover most of its use cases include:
+ *
+ * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v22.x/api/async_context.html#class-asynclocalstorage) tracks async context
+ * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v22.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
+ *
+ * The `node:async_hooks` module provides an API to track asynchronous resources.
+ * It can be accessed using:
+ *
+ * ```js
+ * import async_hooks from 'node:async_hooks';
+ * ```
+ * @experimental
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/async_hooks.js)
+ */
+declare module "async_hooks" {
     /**
      * ```js
      * import { executionAsyncId } from 'node:async_hooks';
@@ -28,7 +44,7 @@ declare module "node:async_hooks" {
      * ```
      *
      * Promise contexts may not get precise `executionAsyncIds` by default.
-     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#promise-execution-tracking).
+     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html#promise-execution-tracking).
      * @since v8.1.0
      * @return The `asyncId` of the current execution context. Useful to track when something calls.
      */
@@ -101,37 +117,43 @@ declare module "node:async_hooks" {
      * ```
      *
      * Promise contexts may not get valid `triggerAsyncId`s by default. See
-     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#promise-execution-tracking).
+     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html#promise-execution-tracking).
      * @return The ID of the resource responsible for calling the callback that is currently being executed.
      */
     function triggerAsyncId(): number;
     interface HookCallbacks {
         /**
-         * The [`init` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#initasyncid-type-triggerasyncid-resource).
+         * Called when a class is constructed that has the possibility to emit an asynchronous event.
+         * @param asyncId A unique ID for the async resource
+         * @param type The type of the async resource
+         * @param triggerAsyncId The unique ID of the async resource in whose execution context this async resource was created
+         * @param resource Reference to the resource representing the async operation, needs to be released during destroy
          */
         init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
         /**
-         * The [`before` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#beforeasyncid).
+         * When an asynchronous operation is initiated or completes a callback is called to notify the user.
+         * The before callback is called just before said callback is executed.
+         * @param asyncId the unique identifier assigned to the resource about to execute the callback.
          */
         before?(asyncId: number): void;
         /**
-         * The [`after` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#afterasyncid).
+         * Called immediately after the callback specified in `before` is completed.
+         *
+         * If an uncaught exception occurs during execution of the callback, then `after` will run after the `'uncaughtException'` event is emitted or a `domain`'s handler runs.
+         * @param asyncId the unique identifier assigned to the resource which has executed the callback.
          */
         after?(asyncId: number): void;
         /**
-         * The [`promiseResolve` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#promiseresolveasyncid).
+         * Called when a promise has resolve() called. This may not be in the same execution id
+         * as the promise itself.
+         * @param asyncId the unique id for the promise that was resolve()d.
          */
         promiseResolve?(asyncId: number): void;
         /**
-         * The [`destroy` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#destroyasyncid).
+         * Called after the resource corresponding to asyncId is destroyed
+         * @param asyncId a unique ID for the async resource
          */
         destroy?(asyncId: number): void;
-        /**
-         * Whether the hook should track `Promise`s. Cannot be `false` if
-         * `promiseResolve` is set.
-         * @default true
-         */
-        trackPromises?: boolean | undefined;
     }
     interface AsyncHook {
         /**
@@ -152,8 +174,7 @@ declare module "node:async_hooks" {
      *
      * All callbacks are optional. For example, if only resource cleanup needs to
      * be tracked, then only the `destroy` callback needs to be passed. The
-     * specifics of all functions that can be passed to `callbacks` is in the
-     * [Hook Callbacks](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#hook-callbacks) section.
+     * specifics of all functions that can be passed to `callbacks` is in the `Hook Callbacks` section.
      *
      * ```js
      * import { createHook } from 'node:async_hooks';
@@ -181,13 +202,12 @@ declare module "node:async_hooks" {
      * ```
      *
      * Because promises are asynchronous resources whose lifecycle is tracked
-     * via the async hooks mechanism, the `init()`, `before()`, `after()`, and
-     * `destroy()` callbacks _must not_ be async functions that return promises.
+     * via the async hooks mechanism, the `init()`, `before()`, `after()`, and`destroy()` callbacks _must not_ be async functions that return promises.
      * @since v8.1.0
-     * @param options The [Hook Callbacks](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#hook-callbacks) to register
-     * @returns Instance used for disabling and enabling hooks
+     * @param callbacks The `Hook Callbacks` to register
+     * @return Instance used for disabling and enabling hooks
      */
-    function createHook(options: HookCallbacks): AsyncHook;
+    function createHook(callbacks: HookCallbacks): AsyncHook;
     interface AsyncResourceOptions {
         /**
          * The ID of the execution context that created this async event.
@@ -300,16 +320,6 @@ declare module "node:async_hooks" {
          */
         triggerAsyncId(): number;
     }
-    interface AsyncLocalStorageOptions {
-        /**
-         * The default value to be used when no store is provided.
-         */
-        defaultValue?: any;
-        /**
-         * A name for the `AsyncLocalStorage` value.
-         */
-        name?: string | undefined;
-    }
     /**
      * This class creates stores that stay coherent through asynchronous operations.
      *
@@ -359,11 +369,6 @@ declare module "node:async_hooks" {
      * @since v13.10.0, v12.17.0
      */
     class AsyncLocalStorage<T> {
-        /**
-         * Creates a new instance of `AsyncLocalStorage`. Store is only provided within a
-         * `run()` call or after an `enterWith()` call.
-         */
-        constructor(options?: AsyncLocalStorageOptions);
         /**
          * Binds the given function to the current execution context.
          * @since v19.8.0
@@ -425,11 +430,6 @@ declare module "node:async_hooks" {
          * @since v13.10.0, v12.17.0
          */
         getStore(): T | undefined;
-        /**
-         * The name of the `AsyncLocalStorage` instance if provided.
-         * @since v24.0.0
-         */
-        readonly name: string;
         /**
          * Runs a function synchronously within a context and returns its
          * return value. The store is not accessible outside of the callback function.
@@ -491,75 +491,6 @@ declare module "node:async_hooks" {
          * @experimental
          */
         exit<R, TArgs extends any[]>(callback: (...args: TArgs) => R, ...args: TArgs): R;
-        /**
-         * Creates a disposable scope that enters the given store and automatically
-         * restores the previous store value when the scope is disposed. This method is
-         * designed to work with JavaScript's explicit resource management (`using` syntax).
-         *
-         * Example:
-         *
-         * ```js
-         * import { AsyncLocalStorage } from 'node:async_hooks';
-         *
-         * const asyncLocalStorage = new AsyncLocalStorage();
-         *
-         * {
-         *   using _ = asyncLocalStorage.withScope('my-store');
-         *   console.log(asyncLocalStorage.getStore()); // Prints: my-store
-         * }
-         *
-         * console.log(asyncLocalStorage.getStore()); // Prints: undefined
-         * ```
-         *
-         * The `withScope()` method is particularly useful for managing context in
-         * synchronous code where you want to ensure the previous store value is restored
-         * when exiting a block, even if an error is thrown.
-         *
-         * ```js
-         * import { AsyncLocalStorage } from 'node:async_hooks';
-         *
-         * const asyncLocalStorage = new AsyncLocalStorage();
-         *
-         * try {
-         *   using _ = asyncLocalStorage.withScope('my-store');
-         *   console.log(asyncLocalStorage.getStore()); // Prints: my-store
-         *   throw new Error('test');
-         * } catch (e) {
-         *   // Store is automatically restored even after error
-         *   console.log(asyncLocalStorage.getStore()); // Prints: undefined
-         * }
-         * ```
-         *
-         * **Important:** When using `withScope()` in async functions before the first
-         * `await`, be aware that the scope change will affect the caller's context. The
-         * synchronous portion of an async function (before the first `await`) runs
-         * immediately when called, and when it reaches the first `await`, it returns the
-         * promise to the caller. At that point, the scope change becomes visible in the
-         * caller's context and will persist in subsequent synchronous code until something
-         * else changes the scope value. For async operations, prefer using `run()` which
-         * properly isolates context across async boundaries.
-         *
-         * ```js
-         * import { AsyncLocalStorage } from 'node:async_hooks';
-         *
-         * const asyncLocalStorage = new AsyncLocalStorage();
-         *
-         * async function example() {
-         *   using _ = asyncLocalStorage.withScope('my-store');
-         *   console.log(asyncLocalStorage.getStore()); // Prints: my-store
-         *   await someAsyncOperation(); // Function pauses here and returns promise
-         *   console.log(asyncLocalStorage.getStore()); // Prints: my-store
-         * }
-         *
-         * // Calling without await
-         * example(); // Synchronous portion runs, then pauses at first await
-         * // After the promise is returned, the scope 'my-store' is now active in caller!
-         * console.log(asyncLocalStorage.getStore()); // Prints: my-store (unexpected!)
-         * ```
-         * @since v25.9.0
-         * @experimental
-         */
-        withScope(store: T): RunScope;
         /**
          * Transitions into the context for the remainder of the current
          * synchronous execution and then persists the store through any following
@@ -602,45 +533,6 @@ declare module "node:async_hooks" {
          */
         enterWith(store: T): void;
     }
-    /**
-     * A disposable scope returned by `asyncLocalStorage.withScope()` that
-     * automatically restores the previous store value when disposed. This class
-     * implements the [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management) protocol and is designed to work
-     * with JavaScript's `using` syntax.
-     *
-     * The scope automatically restores the previous store value when the `using` block
-     * exits, whether through normal completion or by throwing an error.
-     * @since v25.9.0
-     * @experimental
-     */
-    interface RunScope extends Disposable {
-        /**
-         * Explicitly ends the scope and restores the previous store value. This method
-         * is idempotent: calling it multiple times has the same effect as calling it once.
-         *
-         * The `[Symbol.dispose]()` method defers to `dispose()`.
-         *
-         * If `withScope()` is called without the `using` keyword, `dispose()` must be
-         * called manually to restore the previous store value. Forgetting to call
-         * `dispose()` will cause the store value to persist for the remainder of the
-         * current execution context:
-         *
-         * ```js
-         * import { AsyncLocalStorage } from 'node:async_hooks';
-         *
-         * const storage = new AsyncLocalStorage();
-         *
-         * // Without using, the scope must be disposed manually
-         * const scope = storage.withScope('my-store');
-         * // storage.getStore() === 'my-store' here
-         *
-         * scope.dispose(); // Restore previous value
-         * // storage.getStore() === undefined here
-         * ```
-         * @since v25.9.0
-         */
-        dispose(): void;
-    }
     /**
      * @since v17.2.0, v16.14.0
      * @return A map of provider types to the corresponding numeric id.
@@ -706,6 +598,6 @@ declare module "node:async_hooks" {
         const VERIFYREQUEST: number;
     }
 }
-declare module "async_hooks" {
-    export * from "node:async_hooks";
+declare module "node:async_hooks" {
+    export * from "async_hooks";
 }

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

@@ -1,4 +1,4 @@
-declare module "node:buffer" {
+declare module "buffer" {
     type ImplicitArrayBuffer<T extends WithImplicitCoercion<ArrayBufferLike>> = T extends
         { valueOf(): infer V extends ArrayBufferLike } ? V : T;
     global {
@@ -174,7 +174,7 @@ declare module "node:buffer" {
              * If `totalLength` is not provided, it is calculated from the `Buffer` instances
              * in `list` by adding their lengths.
              *
-             * If `totalLength` is provided, it must be an unsigned integer. If the
+             * If `totalLength` is provided, it is coerced to an unsigned integer. If the
              * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
              * truncated to `totalLength`. If the combined length of the `Buffer`s in `list` is
              * less than `totalLength`, the remaining space is filled with zeros.
@@ -316,11 +316,11 @@ declare module "node:buffer" {
              * such `Buffer` instances with zeroes.
              *
              * When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances,
-             * allocations less than `Buffer.poolSize >>> 1` (32KiB when default poolSize is used) are sliced
-             * from a single pre-allocated `Buffer`. This allows applications to avoid the
-             * garbage collection overhead of creating many individually allocated `Buffer`
-             * instances. This approach improves both performance and memory usage by
-             * eliminating the need to track and clean up as many individual `ArrayBuffer` objects.
+             * allocations under 4 KiB are sliced from a single pre-allocated `Buffer`. This
+             * allows applications to avoid the garbage collection overhead of creating many
+             * individually allocated `Buffer` instances. This approach improves both
+             * performance and memory usage by eliminating the need to track and clean up as
+             * many individual `ArrayBuffer` objects.
              *
              * However, in the case where a developer may need to retain a small chunk of
              * memory from a pool for an indeterminate amount of time, it may be appropriate
@@ -463,9 +463,10 @@ declare module "node:buffer" {
          */
         type AllowSharedBuffer = Buffer<ArrayBufferLike>;
     }
-    /**
-     * @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> = T extends NodeJS.ArrayBufferView<infer B> ? Buffer<B> : never;
+    /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+    var SlowBuffer: {
+        /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+        new(size: number): Buffer<ArrayBuffer>;
+        prototype: Buffer;
+    };
 }