@zuplo/cli 6.71.22 → 6.71.23

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

@@ -974,6 +974,8 @@ declare module "node:util" {
      * `reason`.
      *
      * ```js
+     * import util from 'node:util';
+     *
      * function fn() {
      *   return Promise.reject(null);
      * }
@@ -1246,13 +1248,28 @@ declare module "node:util" {
      *
      * The special format value `none` applies no additional styling to the text.
      *
+     * In addition to predefined color names, `util.styleText()` supports hex color
+     * strings using ANSI TrueColor (24-bit) escape sequences. Hex colors can be
+     * specified in either 3-digit (`#RGB`) or 6-digit (`#RRGGBB`) format:
+     *
+     * ```js
+     * import { styleText } from 'node:util';
+     *
+     * // 6-digit hex color
+     * console.log(styleText('#ff5733', 'Orange text'));
+     *
+     * // 3-digit hex color (shorthand)
+     * console.log(styleText('#f00', 'Red text'));
+     * ```
+     *
      * The full list of formats can be found in [modifiers](https://nodejs.org/docs/latest-v26.x/api/util.html#modifiers).
-     * @param format A text format or an Array of text formats defined in `util.inspect.colors`.
+     * @param format A text format or an Array of text formats defined in `util.inspect.colors`, or a hex color in `#RGB`
+     * or `#RRGGBB` form.
      * @param text The text to to be formatted.
      * @since v20.12.0
      */
     export function styleText(
-        format: InspectColor | readonly InspectColor[],
+        format: InspectColor | readonly InspectColor[] | `#${string}`,
         text: string,
         options?: StyleTextOptions,
     ): string;

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

@@ -412,6 +412,21 @@ declare module "node:v8" {
          */
         [Symbol.dispose](): void;
     }
+    /**
+     * @since v26.1.0
+     */
+    interface SyncHeapProfileHandle {
+        /**
+         * Stopping collecting the profile and return the profile data.
+         * @since v26.1.0
+         */
+        stop(): string;
+        /**
+         * Stopping collecting the profile and the profile will be discarded.
+         * @since v26.1.0
+         */
+        [Symbol.dispose](): void;
+    }
     /**
      * @since v24.8.0
      */
@@ -444,18 +459,85 @@ declare module "node:v8" {
          */
         [Symbol.asyncDispose](): Promise<void>;
     }
+    interface CPUProfileOptions {
+        /**
+         * Requested sampling interval in milliseconds. **Default:** `0`.
+         */
+        sampleInterval?: number | undefined;
+        /**
+         * Maximum number of samples to keep before older
+         * entries are discarded. **Default:** `4294967295`.
+         */
+        maxBufferSize?: number | undefined;
+    }
     /**
      * Starting a CPU profile then return a `SyncCPUProfileHandle` object.
      * This API supports `using` syntax.
      *
      * ```js
-     * const handle = v8.startCpuProfile();
+     * const handle = v8.startCpuProfile({ sampleInterval: 1, maxBufferSize: 10_000 });
      * const profile = handle.stop();
      * console.log(profile);
      * ```
      * @since v25.0.0
      */
-    function startCpuProfile(): SyncCPUProfileHandle;
+    function startCpuProfile(options?: CPUProfileOptions): SyncCPUProfileHandle;
+    interface HeapProfileOptions {
+        /**
+         * The average sampling interval in bytes.
+         * **Default:** `524288` (512 KiB).
+         */
+        sampleInterval?: number | undefined;
+        /**
+         * The maximum stack depth for samples.
+         * **Default:** `16`.
+         */
+        stackDepth?: number | undefined;
+        /**
+         * Force garbage collection before taking the profile.
+         * **Default:** `false`.
+         */
+        forceGC?: boolean | undefined;
+        /**
+         * Include objects collected
+         * by major GC. **Default:** `false`.
+         */
+        includeObjectsCollectedByMajorGC?: boolean | undefined;
+        /**
+         * Include objects collected
+         * by minor GC. **Default:** `false`.
+         */
+        includeObjectsCollectedByMinorGC?: boolean | undefined;
+    }
+    /**
+     * Starting a heap profile then return a `SyncHeapProfileHandle` object.
+     * This API supports `using` syntax.
+     *
+     * ```js
+     * import v8 from 'node:v8';
+     *
+     * const handle = v8.startHeapProfile();
+     * const profile = handle.stop();
+     * console.log(profile);
+     * ```
+     *
+     * With custom parameters:
+     *
+     * ```js
+     * import v8 from 'node:v8';
+     *
+     * const handle = v8.startHeapProfile({
+     *   sampleInterval: 1024,
+     *   stackDepth: 8,
+     *   forceGC: true,
+     *   includeObjectsCollectedByMajorGC: true,
+     * });
+     * const profile = handle.stop();
+     * console.log(profile);
+     * ```
+     * @since v26.1.0
+     */
+    function startHeapProfile(options?: HeapProfileOptions): SyncHeapProfileHandle;
     /**
      * V8 only supports `Latin-1/ISO-8859-1` and `UTF16` as the underlying representation of a string.
      * If the `content` uses `Latin-1/ISO-8859-1` as the underlying representation, this function will return true;

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

@@ -10,7 +10,7 @@ declare module "node:worker_threads" {
     import { Readable, Writable } from "node:stream";
     import { ReadableStream, TransformStream, WritableStream } from "node:stream/web";
     import { URL } from "node:url";
-    import { CPUProfileHandle, HeapInfo, HeapProfileHandle } from "node:v8";
+    import { CPUProfileHandle, CPUProfileOptions, HeapInfo, HeapProfileHandle, HeapProfileOptions } from "node:v8";
     import { Context } from "node:vm";
     import { MessageEvent } from "undici-types";
     const isInternalThread: boolean;
@@ -259,7 +259,7 @@ declare module "node:worker_threads" {
          *   `, { eval: true });
          *
          * worker.on('online', async () => {
-         *   const handle = await worker.startCpuProfile();
+         *   const handle = await worker.startCpuProfile({ sampleInterval: 1 });
          *   const profile = await handle.stop();
          *   console.log(profile);
          *   worker.terminate();
@@ -283,16 +283,16 @@ declare module "node:worker_threads" {
          * ```
          * @since v24.8.0
          */
-        startCpuProfile(): Promise<CPUProfileHandle>;
+        startCpuProfile(options?: CPUProfileOptions): Promise<CPUProfileHandle>;
         /**
          * Starting a Heap profile then return a Promise that fulfills with an error
          * or an `HeapProfileHandle` object. This API supports `await using` syntax.
          *
          * ```js
-         * const { Worker } = require('node:worker_threads');
+         * import { Worker } from 'node:worker_threads';
          *
          * const worker = new Worker(`
-         *   const { parentPort } = require('worker_threads');
+         *   const { parentPort } = require('node:worker_threads');
          *   parentPort.on('message', () => {});
          *   `, { eval: true });
          *
@@ -307,7 +307,7 @@ declare module "node:worker_threads" {
          * `await using` example.
          *
          * ```js
-         * const { Worker } = require('node:worker_threads');
+         * import { Worker } from 'node:worker_threads';
          *
          * const w = new Worker(`
          *   const { parentPort } = require('node:worker_threads');
@@ -319,8 +319,9 @@ declare module "node:worker_threads" {
          *   await using handle = await w.startHeapProfile();
          * });
          * ```
+         * @since v24.9.0
          */
-        startHeapProfile(): Promise<HeapProfileHandle>;
+        startHeapProfile(options?: HeapProfileOptions): Promise<HeapProfileHandle>;
         /**
          * Calls `worker.terminate()` when the dispose scope is exited.
          *

package/node_modules/@zuplo/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuplo/core",
-  "version": "6.71.22",
+  "version": "6.71.23",
   "repository": "https://github.com/zuplo/zuplo",
   "author": "Zuplo, Inc.",
   "type": "module",