openclaw-multi-auto 1.2.7 → 1.2.9

package/node_modules/.pnpm/protobufjs@7.5.4/node_modules/@types/node/cluster.d.ts

@@ -1,486 +0,0 @@
-/**
- * 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`](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html)
- * 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.
- *
- * ```js
- * import cluster from 'node:cluster';
- * import http from 'node:http';
- * import { availableParallelism } from 'node:os';
- * import process from 'node:process';
- *
- * const numCPUs = availableParallelism();
- *
- * if (cluster.isPrimary) {
- *   console.log(`Primary ${process.pid} is running`);
- *
- *   // Fork workers.
- *   for (let i = 0; i < numCPUs; i++) {
- *     cluster.fork();
- *   }
- *
- *   cluster.on('exit', (worker, code, signal) => {
- *     console.log(`worker ${worker.process.pid} died`);
- *   });
- * } else {
- *   // Workers can share any TCP connection
- *   // In this case it is an HTTP server
- *   http.createServer((req, res) => {
- *     res.writeHead(200);
- *     res.end('hello world\n');
- *   }).listen(8000);
- *
- *   console.log(`Worker ${process.pid} started`);
- * }
- * ```
- *
- * Running Node.js will now share port 8000 between the workers:
- *
- * ```console
- * $ node server.js
- * Primary 3596 is running
- * Worker 4324 started
- * Worker 4520 started
- * Worker 6056 started
- * Worker 5644 started
- * ```
- *
- * 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/v25.x/lib/cluster.js)
- */
-declare module "node:cluster" {
-    import * as child_process from "node:child_process";
-    import { EventEmitter, InternalEventEmitter } from "node:events";
-    class Worker implements EventEmitter {
-        constructor(options?: cluster.WorkerOptions);
-        /**
-         * Each new worker is given its own unique id, this id is stored in the `id`.
-         *
-         * While a worker is alive, this is the key that indexes it in `cluster.workers`.
-         * @since v0.8.0
-         */
-        id: number;
-        /**
-         * All workers are created using [`child_process.fork()`](https://nodejs.org/docs/latest-v25.x/api/child_process.html#child_processforkmodulepath-args-options), the returned object
-         * from this function is stored as `.process`. In a worker, the global `process` is stored.
-         *
-         * See: [Child Process module](https://nodejs.org/docs/latest-v25.x/api/child_process.html#child_processforkmodulepath-args-options).
-         *
-         * Workers will call `process.exit(0)` if the `'disconnect'` event occurs
-         * on `process` and `.exitedAfterDisconnect` is not `true`. This protects against
-         * accidental disconnection.
-         * @since v0.7.0
-         */
-        process: child_process.ChildProcess;
-        /**
-         * 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()`](https://nodejs.org/docs/latest-v25.x/api/child_process.html#subprocesssendmessage-sendhandle-options-callback).
-         *
-         * 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:
-         *
-         * ```js
-         * if (cluster.isPrimary) {
-         *   const worker = cluster.fork();
-         *   worker.send('hi there');
-         *
-         * } else if (cluster.isWorker) {
-         *   process.on('message', (msg) => {
-         *     process.send(msg);
-         *   });
-         * }
-         * ```
-         * @since v0.7.0
-         * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles.
-         */
-        send(message: child_process.Serializable, callback?: (error: Error | null) => void): boolean;
-        send(
-            message: child_process.Serializable,
-            sendHandle: child_process.SendHandle,
-            callback?: (error: Error | null) => void,
-        ): boolean;
-        send(
-            message: child_process.Serializable,
-            sendHandle: child_process.SendHandle,
-            options?: child_process.MessageOptions,
-            callback?: (error: Error | null) => void,
-        ): boolean;
-        /**
-         * 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`.
-         *
-         * The `kill()` function kills the worker process without waiting for a graceful
-         * disconnect, it has the same behavior as `worker.process.kill()`.
-         *
-         * 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()`](https://nodejs.org/docs/latest-v25.x/api/process.html#processkillpid-signal).
-         * @since v0.9.12
-         * @param [signal='SIGTERM'] Name of the kill signal to send to the worker process.
-         */
-        kill(signal?: string): void;
-        destroy(signal?: string): void;
-        /**
-         * In a worker, this function will close all servers, wait for the `'close'` event
-         * on those servers, and then disconnect the IPC channel.
-         *
-         * In the primary, an internal message is sent to the worker causing it to call `.disconnect()` on itself.
-         *
-         * Causes `.exitedAfterDisconnect` to be set.
-         *
-         * After a server is closed, it will no longer accept new connections,
-         * but connections may be accepted by any other listening worker. Existing
-         * connections will be allowed to close as usual. When no more connections exist,
-         * see `server.close()`, the IPC channel to the worker will close allowing it
-         * to die gracefully.
-         *
-         * The above applies _only_ to server connections, client connections are not
-         * automatically closed by workers, and disconnect does not wait for them to close
-         * before exiting.
-         *
-         * In a worker, `process.disconnect` exists, but it is not this function;
-         * it is `disconnect()`.
-         *
-         * Because long living server connections may block workers from disconnecting, it
-         * may be useful to send a message, so application specific actions may be taken to
-         * close them. It also may be useful to implement a timeout, killing a worker if
-         * the `'disconnect'` event has not been emitted after some time.
-         *
-         * ```js
-         * import net from 'node:net';
-         *
-         * if (cluster.isPrimary) {
-         *   const worker = cluster.fork();
-         *   let timeout;
-         *
-         *   worker.on('listening', (address) => {
-         *     worker.send('shutdown');
-         *     worker.disconnect();
-         *     timeout = setTimeout(() => {
-         *       worker.kill();
-         *     }, 2000);
-         *   });
-         *
-         *   worker.on('disconnect', () => {
-         *     clearTimeout(timeout);
-         *   });
-         *
-         * } else if (cluster.isWorker) {
-         *   const server = net.createServer((socket) => {
-         *     // Connections never end
-         *   });
-         *
-         *   server.listen(8000);
-         *
-         *   process.on('message', (msg) => {
-         *     if (msg === 'shutdown') {
-         *       // Initiate graceful close of any connections to server
-         *     }
-         *   });
-         * }
-         * ```
-         * @since v0.7.7
-         * @return A reference to `worker`.
-         */
-        disconnect(): this;
-        /**
-         * This function returns `true` if the worker is connected to its primary via its
-         * IPC channel, `false` otherwise. A worker is connected to its primary after it
-         * has been created. It is disconnected after the `'disconnect'` event is emitted.
-         * @since v0.11.14
-         */
-        isConnected(): boolean;
-        /**
-         * This function returns `true` if the worker's process has terminated (either
-         * because of exiting or being signaled). Otherwise, it returns `false`.
-         *
-         * ```js
-         * import cluster from 'node:cluster';
-         * import http from 'node:http';
-         * import { availableParallelism } from 'node:os';
-         * import process from 'node:process';
-         *
-         * const numCPUs = availableParallelism();
-         *
-         * if (cluster.isPrimary) {
-         *   console.log(`Primary ${process.pid} is running`);
-         *
-         *   // Fork workers.
-         *   for (let i = 0; i < numCPUs; i++) {
-         *     cluster.fork();
-         *   }
-         *
-         *   cluster.on('fork', (worker) => {
-         *     console.log('worker is dead:', worker.isDead());
-         *   });
-         *
-         *   cluster.on('exit', (worker, code, signal) => {
-         *     console.log('worker is dead:', worker.isDead());
-         *   });
-         * } else {
-         *   // Workers can share any TCP connection. In this case, it is an HTTP server.
-         *   http.createServer((req, res) => {
-         *     res.writeHead(200);
-         *     res.end(`Current process\n ${process.pid}`);
-         *     process.kill(process.pid);
-         *   }).listen(8000);
-         * }
-         * ```
-         * @since v0.11.14
-         */
-        isDead(): boolean;
-        /**
-         * 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
-         * voluntary and accidental exit, the primary may choose not to respawn a worker
-         * based on this value.
-         *
-         * ```js
-         * cluster.on('exit', (worker, code, signal) => {
-         *   if (worker.exitedAfterDisconnect === true) {
-         *     console.log('Oh, it was just voluntary – no need to worry');
-         *   }
-         * });
-         *
-         * // kill worker
-         * worker.kill();
-         * ```
-         * @since v6.0.0
-         */
-        exitedAfterDisconnect: boolean;
-    }
-    interface Worker extends InternalEventEmitter<cluster.WorkerEventMap> {}
-    type _Worker = Worker;
-    namespace cluster {
-        interface Worker extends _Worker {}
-        interface WorkerOptions {
-            id?: number | undefined;
-            process?: child_process.ChildProcess | undefined;
-            state?: string | undefined;
-        }
-        interface WorkerEventMap {
-            "disconnect": [];
-            "error": [error: Error];
-            "exit": [code: number, signal: string];
-            "listening": [address: Address];
-            "message": [message: any, handle: child_process.SendHandle];
-            "online": [];
-        }
-        interface ClusterSettings {
-            /**
-             * List of string arguments passed to the Node.js executable.
-             * @default process.execArgv
-             */
-            execArgv?: string[] | undefined;
-            /**
-             * File path to worker file.
-             * @default process.argv[1]
-             */
-            exec?: string | undefined;
-            /**
-             * String arguments passed to worker.
-             * @default process.argv.slice(2)
-             */
-            args?: readonly string[] | undefined;
-            /**
-             * Whether or not to send output to parent's stdio.
-             * @default false
-             */
-            silent?: boolean | undefined;
-            /**
-             * Configures the stdio of forked processes. Because the cluster module relies on IPC to function, this configuration must
-             * contain an `'ipc'` entry. When this option is provided, it overrides `silent`. See [`child_prcess.spawn()`](https://nodejs.org/docs/latest-v25.x/api/child_process.html#child_processspawncommand-args-options)'s
-             * [`stdio`](https://nodejs.org/docs/latest-v25.x/api/child_process.html#optionsstdio).
-             */
-            stdio?: any[] | undefined;
-            /**
-             * Sets the user identity of the process. (See [`setuid(2)`](https://man7.org/linux/man-pages/man2/setuid.2.html).)
-             */
-            uid?: number | undefined;
-            /**
-             * Sets the group identity of the process. (See [`setgid(2)`](https://man7.org/linux/man-pages/man2/setgid.2.html).)
-             */
-            gid?: number | undefined;
-            /**
-             * Sets inspector port of worker. This can be a number, or a function that takes no arguments and returns a number.
-             * By default each worker gets its own port, incremented from the primary's `process.debugPort`.
-             */
-            inspectPort?: number | (() => number) | undefined;
-            /**
-             * Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`.
-             * See [Advanced serialization for `child_process`](https://nodejs.org/docs/latest-v25.x/api/child_process.html#advanced-serialization) for more details.
-             * @default false
-             */
-            serialization?: "json" | "advanced" | undefined;
-            /**
-             * Current working directory of the worker process.
-             * @default undefined (inherits from parent process)
-             */
-            cwd?: string | undefined;
-            /**
-             * Hide the forked processes console window that would normally be created on Windows systems.
-             * @default false
-             */
-            windowsHide?: boolean | undefined;
-        }
-        interface Address {
-            address: string;
-            port: number;
-            /**
-             * The `addressType` is one of:
-             *
-             * * `4` (TCPv4)
-             * * `6` (TCPv6)
-             * * `-1` (Unix domain socket)
-             * * `'udp4'` or `'udp6'` (UDPv4 or UDPv6)
-             */
-            addressType: 4 | 6 | -1 | "udp4" | "udp6";
-        }
-        interface ClusterEventMap {
-            "disconnect": [worker: Worker];
-            "exit": [worker: Worker, code: number, signal: string];
-            "fork": [worker: Worker];
-            "listening": [worker: Worker, address: Address];
-            "message": [worker: Worker, message: any, handle: child_process.SendHandle];
-            "online": [worker: Worker];
-            "setup": [settings: ClusterSettings];
-        }
-        interface Cluster extends InternalEventEmitter<ClusterEventMap> {
-            /**
-             * A `Worker` object contains all public information and method about a worker.
-             * In the primary it can be obtained using `cluster.workers`. In a worker
-             * it can be obtained using `cluster.worker`.
-             * @since v0.7.0
-             */
-            Worker: typeof Worker;
-            disconnect(callback?: () => void): void;
-            /**
-             * Spawn a new worker process.
-             *
-             * This can only be called from the primary process.
-             * @param env Key/value pairs to add to worker process environment.
-             * @since v0.6.0
-             */
-            fork(env?: any): Worker;
-            /** @deprecated since v16.0.0 - use isPrimary. */
-            readonly isMaster: boolean;
-            /**
-             * True if the process is a primary. This is determined by the `process.env.NODE_UNIQUE_ID`. If `process.env.NODE_UNIQUE_ID`
-             * is undefined, then `isPrimary` is `true`.
-             * @since v16.0.0
-             */
-            readonly isPrimary: boolean;
-            /**
-             * True if the process is not a primary (it is the negation of `cluster.isPrimary`).
-             * @since v0.6.0
-             */
-            readonly isWorker: boolean;
-            /**
-             * The scheduling policy, either `cluster.SCHED_RR` for round-robin or `cluster.SCHED_NONE` to leave it to the operating system. This is a
-             * global setting and effectively frozen once either the first worker is spawned, or [`.setupPrimary()`](https://nodejs.org/docs/latest-v25.x/api/cluster.html#clustersetupprimarysettings)
-             * is called, whichever comes first.
-             *
-             * `SCHED_RR` is the default on all operating systems except Windows. Windows will change to `SCHED_RR` once libuv is able to effectively distribute
-             * IOCP handles without incurring a large performance hit.
-             *
-             * `cluster.schedulingPolicy` can also be set through the `NODE_CLUSTER_SCHED_POLICY` environment variable. Valid values are `'rr'` and `'none'`.
-             * @since v0.11.2
-             */
-            schedulingPolicy: number;
-            /**
-             * After calling [`.setupPrimary()`](https://nodejs.org/docs/latest-v25.x/api/cluster.html#clustersetupprimarysettings)
-             * (or [`.fork()`](https://nodejs.org/docs/latest-v25.x/api/cluster.html#clusterforkenv)) this settings object will contain
-             * the settings, including the default values.
-             *
-             * This object is not intended to be changed or set manually.
-             * @since v0.7.1
-             */
-            readonly settings: ClusterSettings;
-            /** @deprecated since v16.0.0 - use [`.setupPrimary()`](https://nodejs.org/docs/latest-v25.x/api/cluster.html#clustersetupprimarysettings) instead. */
-            setupMaster(settings?: ClusterSettings): void;
-            /**
-             * `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in `cluster.settings`.
-             *
-             * Any settings changes only affect future calls to [`.fork()`](https://nodejs.org/docs/latest-v25.x/api/cluster.html#clusterforkenv)
-             * and have no effect on workers that are already running.
-             *
-             * The only attribute of a worker that cannot be set via `.setupPrimary()` is the `env` passed to
-             * [`.fork()`](https://nodejs.org/docs/latest-v25.x/api/cluster.html#clusterforkenv).
-             *
-             * The defaults above apply to the first call only; the defaults for later calls are the current values at the time of
-             * `cluster.setupPrimary()` is called.
-             *
-             * ```js
-             * import cluster from 'node:cluster';
-             *
-             * cluster.setupPrimary({
-             *   exec: 'worker.js',
-             *   args: ['--use', 'https'],
-             *   silent: true,
-             * });
-             * cluster.fork(); // https worker
-             * cluster.setupPrimary({
-             *   exec: 'worker.js',
-             *   args: ['--use', 'http'],
-             * });
-             * cluster.fork(); // http worker
-             * ```
-             *
-             * This can only be called from the primary process.
-             * @since v16.0.0
-             */
-            setupPrimary(settings?: ClusterSettings): void;
-            /**
-             * A reference to the current worker object. Not available in the primary process.
-             *
-             * ```js
-             * import cluster from 'node:cluster';
-             *
-             * if (cluster.isPrimary) {
-             *   console.log('I am primary');
-             *   cluster.fork();
-             *   cluster.fork();
-             * } else if (cluster.isWorker) {
-             *   console.log(`I am worker #${cluster.worker.id}`);
-             * }
-             * ```
-             * @since v0.7.0
-             */
-            readonly worker?: Worker;
-            /**
-             * A hash that stores the active worker objects, keyed by `id` field. This makes it easy to loop through all the workers. It is only available in the primary process.
-             *
-             * A worker is removed from `cluster.workers` after the worker has disconnected _and_ exited. The order between these two events cannot be determined in advance. However, it
-             * is guaranteed that the removal from the `cluster.workers` list happens before the last `'disconnect'` or `'exit'` event is emitted.
-             *
-             * ```js
-             * import cluster from 'node:cluster';
-             *
-             * for (const worker of Object.values(cluster.workers)) {
-             *   worker.send('big announcement to all workers');
-             * }
-             * ```
-             * @since v0.7.0
-             */
-            readonly workers?: NodeJS.Dict<Worker>;
-            readonly SCHED_NONE: number;
-            readonly SCHED_RR: number;
-        }
-    }
-    var cluster: cluster.Cluster;
-    export = cluster;
-}
-declare module "cluster" {
-    import cluster = require("node:cluster");
-    export = cluster;
-}

package/node_modules/.pnpm/protobufjs@7.5.4/node_modules/@types/node/compatibility/iterators.d.ts

@@ -1,21 +0,0 @@
-// Backwards-compatible iterator interfaces, augmented with iterator helper methods by lib.esnext.iterator in TypeScript 5.6.
-// The IterableIterator interface does not contain these methods, which creates assignability issues in places where IteratorObjects
-// are expected (eg. DOM-compatible APIs) if lib.esnext.iterator is loaded.
-// Also ensures that iterators returned by the Node API, which inherit from Iterator.prototype, correctly expose the iterator helper methods
-// if lib.esnext.iterator is loaded.
-// TODO: remove once this package no longer supports TS 5.5, and replace NodeJS.BuiltinIteratorReturn with BuiltinIteratorReturn.
-
-// Placeholders for TS <5.6
-interface IteratorObject<T, TReturn, TNext> {}
-interface AsyncIteratorObject<T, TReturn, TNext> {}
-
-declare namespace NodeJS {
-    // Populate iterator methods for TS <5.6
-    interface Iterator<T, TReturn, TNext> extends globalThis.Iterator<T, TReturn, TNext> {}
-    interface AsyncIterator<T, TReturn, TNext> extends globalThis.AsyncIterator<T, TReturn, TNext> {}
-
-    // Polyfill for TS 5.6's instrinsic BuiltinIteratorReturn type, required for DOM-compatible iterators
-    type BuiltinIteratorReturn = ReturnType<any[][typeof Symbol.iterator]> extends
-        globalThis.Iterator<any, infer TReturn> ? TReturn
-        : any;
-}

package/node_modules/.pnpm/protobufjs@7.5.4/node_modules/@types/node/console.d.ts

@@ -1,151 +0,0 @@
-/**
- * The `node:console` module provides a simple debugging console that is similar to
- * the JavaScript console mechanism provided by web browsers.
- *
- * The module exports two specific components:
- *
- * * A `Console` class with methods such as `console.log()`, `console.error()`, and `console.warn()` that can be used to write to any Node.js stream.
- * * A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstdout) and
- * [`process.stderr`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
- *
- * _**Warning**_: The global console object's methods are neither consistently
- * synchronous like the browser APIs they resemble, nor are they consistently
- * asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v25.x/api/process.html#a-note-on-process-io) for
- * more information.
- *
- * Example using the global `console`:
- *
- * ```js
- * console.log('hello world');
- * // Prints: hello world, to stdout
- * console.log('hello %s', 'world');
- * // Prints: hello world, to stdout
- * console.error(new Error('Whoops, something bad happened'));
- * // Prints error message and stack trace to stderr:
- * //   Error: Whoops, something bad happened
- * //     at [eval]:5:15
- * //     at Script.runInThisContext (node:vm:132:18)
- * //     at Object.runInThisContext (node:vm:309:38)
- * //     at node:internal/process/execution:77:19
- * //     at [eval]-wrapper:6:22
- * //     at evalScript (node:internal/process/execution:76:60)
- * //     at node:internal/main/eval_string:23:3
- *
- * const name = 'Will Robinson';
- * console.warn(`Danger ${name}! Danger!`);
- * // Prints: Danger Will Robinson! Danger!, to stderr
- * ```
- *
- * Example using the `Console` class:
- *
- * ```js
- * const out = getStreamSomehow();
- * const err = getStreamSomehow();
- * const myConsole = new console.Console(out, err);
- *
- * myConsole.log('hello world');
- * // Prints: hello world, to out
- * myConsole.log('hello %s', 'world');
- * // Prints: hello world, to out
- * myConsole.error(new Error('Whoops, something bad happened'));
- * // Prints: [Error: Whoops, something bad happened], to err
- *
- * const name = 'Will Robinson';
- * myConsole.warn(`Danger ${name}! Danger!`);
- * // Prints: Danger Will Robinson! Danger!, to err
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/console.js)
- */
-declare module "node:console" {
-    import { InspectOptions } from "node:util";
-    namespace console {
-        interface ConsoleOptions {
-            stdout: NodeJS.WritableStream;
-            stderr?: NodeJS.WritableStream | undefined;
-            /**
-             * Ignore errors when writing to the underlying streams.
-             * @default true
-             */
-            ignoreErrors?: boolean | undefined;
-            /**
-             * Set color support for this `Console` instance. Setting to true enables coloring while inspecting
-             * values. Setting to `false` disables coloring while inspecting values. Setting to `'auto'` makes color
-             * support depend on the value of the `isTTY` property and the value returned by `getColorDepth()` on the
-             * respective stream. This option can not be used, if `inspectOptions.colors` is set as well.
-             * @default 'auto'
-             */
-            colorMode?: boolean | "auto" | undefined;
-            /**
-             * Specifies options that are passed along to
-             * [`util.inspect()`](https://nodejs.org/docs/latest-v25.x/api/util.html#utilinspectobject-options).
-             */
-            inspectOptions?: InspectOptions | ReadonlyMap<NodeJS.WritableStream, InspectOptions> | undefined;
-            /**
-             * Set group indentation.
-             * @default 2
-             */
-            groupIndentation?: number | undefined;
-        }
-        interface Console {
-            readonly Console: {
-                prototype: Console;
-                new(stdout: NodeJS.WritableStream, stderr?: NodeJS.WritableStream, ignoreErrors?: boolean): Console;
-                new(options: ConsoleOptions): Console;
-            };
-            assert(condition?: unknown, ...data: any[]): void;
-            clear(): void;
-            count(label?: string): void;
-            countReset(label?: string): void;
-            debug(...data: any[]): void;
-            dir(item?: any, options?: InspectOptions): void;
-            dirxml(...data: any[]): void;
-            error(...data: any[]): void;
-            group(...data: any[]): void;
-            groupCollapsed(...data: any[]): void;
-            groupEnd(): void;
-            info(...data: any[]): void;
-            log(...data: any[]): void;
-            table(tabularData?: any, properties?: string[]): void;
-            time(label?: string): void;
-            timeEnd(label?: string): void;
-            timeLog(label?: string, ...data: any[]): void;
-            trace(...data: any[]): void;
-            warn(...data: any[]): void;
-            /**
-             * This method does not display anything unless used in the inspector. The `console.profile()`
-             * method starts a JavaScript CPU profile with an optional label until {@link profileEnd}
-             * is called. The profile is then added to the Profile panel of the inspector.
-             *
-             * ```js
-             * console.profile('MyLabel');
-             * // Some code
-             * console.profileEnd('MyLabel');
-             * // Adds the profile 'MyLabel' to the Profiles panel of the inspector.
-             * ```
-             * @since v8.0.0
-             */
-            profile(label?: string): void;
-            /**
-             * This method does not display anything unless used in the inspector. Stops the current
-             * JavaScript CPU profiling session if one has been started and prints the report to the
-             * Profiles panel of the inspector. See {@link profile} for an example.
-             *
-             * If this method is called without a label, the most recently started profile is stopped.
-             * @since v8.0.0
-             */
-            profileEnd(label?: string): void;
-            /**
-             * This method does not display anything unless used in the inspector. The `console.timeStamp()`
-             * method adds an event with the label `'label'` to the Timeline panel of the inspector.
-             * @since v8.0.0
-             */
-            timeStamp(label?: string): void;
-        }
-    }
-    var console: console.Console;
-    export = console;
-}
-declare module "console" {
-    import console = require("node:console");
-    export = console;
-}

package/node_modules/.pnpm/protobufjs@7.5.4/node_modules/@types/node/constants.d.ts

@@ -1,20 +0,0 @@
-/**
- * @deprecated The `node:constants` module is deprecated. When requiring access to constants
- * relevant to specific Node.js builtin modules, developers should instead refer
- * to the `constants` property exposed by the relevant module. For instance,
- * `require('node:fs').constants` and `require('node:os').constants`.
- */
-declare module "node:constants" {
-    const constants:
-        & typeof import("node:os").constants.dlopen
-        & typeof import("node:os").constants.errno
-        & typeof import("node:os").constants.priority
-        & typeof import("node:os").constants.signals
-        & typeof import("node:fs").constants
-        & typeof import("node:crypto").constants;
-    export = constants;
-}
-declare module "constants" {
-    import constants = require("node:constants");
-    export = constants;
-}