nx 22.5.0-beta.2 → 22.5.0-beta.3

package/src/daemon/client/client.js

@@ -790,13 +790,13 @@ class DaemonClient {
             this.establishConnection();
             // Resend the pending message if one exists
             if (this.currentMessage && this.currentResolve && this.currentReject) {
-                // Decrement the queue counter that was incremented when the error occurred
-                this.queue.decrementQueueCounter();
-                // Retry the message through the normal queue
+                // Retry the message directly (not through the queue) to resolve the
+                // pending promise that the original queue entry is waiting on.
+                // This allows the original queue entry to complete naturally.
                 const msg = this.currentMessage;
                 const res = this.currentResolve;
                 const rej = this.currentReject;
-                this.sendToDaemonViaQueue(msg).then(res, rej);
+                this.sendMessageToDaemon(msg).then(res, rej);
             }
         }
         else {

package/src/project-graph/plugins/get-plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-plugins.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/plugins/get-plugins.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAwBzD,wBAAsB,UAAU,CAC9B,IAAI,SAAgB,GACnB,OAAO,CAAC,cAAc,EAAE,CAAC,CAwB3B;AAaD,wBAAsB,qBAAqB,CAAC,IAAI,SAAgB,6BAyB/D;AAED,wBAAgB,cAAc,SAK7B"}
+{"version":3,"file":"get-plugins.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/plugins/get-plugins.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAwBzD,wBAAsB,UAAU,CAC9B,IAAI,SAAgB,GACnB,OAAO,CAAC,cAAc,EAAE,CAAC,CA6C3B;AAaD,wBAAsB,qBAAqB,CAAC,IAAI,SAAgB,6BAyB/D;AAED,wBAAgB,cAAc,SAK7B"}

package/src/project-graph/plugins/get-plugins.js

@@ -31,10 +31,27 @@ async function getPlugins(root = workspace_root_1.workspaceRoot) {
         return loadedPlugins;
     }
     currentPluginsConfigurationHash = pluginsConfigurationHash;
-    const [defaultPlugins, specifiedPlugins] = await Promise.all([
+    const results = await Promise.allSettled([
         getOnlyDefaultPlugins(root),
         (pendingPluginsPromise ??= loadSpecifiedNxPlugins(pluginsConfiguration, root)),
     ]);
+    const errors = [];
+    const defaultPlugins = [];
+    const specifiedPlugins = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === 'fulfilled') {
+            (i === 0 ? defaultPlugins : specifiedPlugins).push(...result.value);
+        }
+        else {
+            errors.push(result.reason instanceof Error
+                ? result.reason
+                : new Error(String(result.reason)));
+        }
+    }
+    if (errors.length > 0) {
+        throw new AggregateError(errors, errors.map((e) => e.message).join('\n'));
+    }
     loadedPlugins = specifiedPlugins.concat(defaultPlugins);
     return loadedPlugins;
 }
@@ -79,16 +96,42 @@ async function loadDefaultNxPlugins(root = workspace_root_1.workspaceRoot) {
     performance.mark('loadDefaultNxPlugins:start');
     const plugins = getDefaultPlugins(root);
     const cleanupFunctions = [];
+    const results = await Promise.allSettled(plugins.map(async (plugin) => {
+        performance.mark(`Load Nx Plugin: ${plugin} - start`);
+        const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
+        cleanupFunctions.push(cleanup);
+        const res = await loadedPluginPromise;
+        performance.mark(`Load Nx Plugin: ${plugin} - end`);
+        performance.measure(`Load Nx Plugin: ${plugin}`, `Load Nx Plugin: ${plugin} - start`, `Load Nx Plugin: ${plugin} - end`);
+        return res;
+    }));
+    const defaultPluginResults = [];
+    const errors = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === 'fulfilled') {
+            defaultPluginResults.push(result.value);
+        }
+        else {
+            errors.push({
+                pluginName: plugins[i],
+                error: result.reason instanceof Error
+                    ? result.reason
+                    : new Error(String(result.reason)),
+            });
+        }
+    }
+    if (errors.length > 0) {
+        for (const fn of cleanupFunctions) {
+            fn();
+        }
+        const errorMessage = errors
+            .map((e) => `  - ${e.pluginName}: ${e.error.message}`)
+            .join('\n');
+        throw new AggregateError(errors.map((e) => e.error), `Failed to load ${errors.length} default Nx plugin(s):\n${errorMessage}`);
+    }
     const ret = [
-        await Promise.all(plugins.map(async (plugin) => {
-            performance.mark(`Load Nx Plugin: ${plugin} - start`);
-            const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
-            cleanupFunctions.push(cleanup);
-            const res = await loadedPluginPromise;
-            performance.mark(`Load Nx Plugin: ${plugin} - end`);
-            performance.measure(`Load Nx Plugin: ${plugin}`, `Load Nx Plugin: ${plugin} - start`, `Load Nx Plugin: ${plugin} - end`);
-            return res;
-        })),
+        defaultPluginResults,
         () => {
             for (const fn of cleanupFunctions) {
                 fn();
@@ -111,7 +154,7 @@ async function loadSpecifiedNxPlugins(pluginsConfigurations, root = workspace_ro
     performance.mark('loadSpecifiedNxPlugins:start');
     pluginsConfigurations ??= [];
     const cleanupFunctions = [];
-    const plugins = await Promise.all(pluginsConfigurations.map(async (plugin, index) => {
+    const results = await Promise.allSettled(pluginsConfigurations.map(async (plugin, index) => {
         const pluginPath = typeof plugin === 'string' ? plugin : plugin.plugin;
         performance.mark(`Load Nx Plugin: ${pluginPath} - start`);
         const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root, index);
@@ -124,6 +167,33 @@ async function loadSpecifiedNxPlugins(pluginsConfigurations, root = workspace_ro
     }));
     performance.mark('loadSpecifiedNxPlugins:end');
     performance.measure('loadSpecifiedNxPlugins', 'loadSpecifiedNxPlugins:start', 'loadSpecifiedNxPlugins:end');
+    const plugins = [];
+    const errors = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === 'fulfilled') {
+            plugins.push(result.value);
+        }
+        else {
+            const pluginConfig = pluginsConfigurations[i];
+            const pluginName = typeof pluginConfig === 'string' ? pluginConfig : pluginConfig.plugin;
+            errors.push({
+                pluginName,
+                error: result.reason instanceof Error
+                    ? result.reason
+                    : new Error(String(result.reason)),
+            });
+        }
+    }
+    if (errors.length > 0) {
+        for (const fn of cleanupFunctions) {
+            fn();
+        }
+        const errorMessage = errors
+            .map((e) => `  - ${e.pluginName}: ${e.error.message}`)
+            .join('\n');
+        throw new AggregateError(errors.map((e) => e.error), `Failed to load ${errors.length} Nx plugin(s):\n${errorMessage}`);
+    }
     cleanupSpecifiedPlugins = () => {
         for (const fn of cleanupFunctions) {
             fn();

package/src/project-graph/plugins/isolation/plugin-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-pool.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/plugins/isolation/plugin-pool.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAO9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AA4C1D,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,CAmGhD"}
+{"version":3,"file":"plugin-pool.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/plugins/isolation/plugin-pool.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAM9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AA4C1D,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,CAmGhD"}

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -4,8 +4,7 @@ exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
 const child_process_1 = require("child_process");
 const net_1 = require("net");
 const path = require("path");
-// TODO (@AgentEnder): After scoped verbose logging is implemented, re-add verbose logs here.
-// import { logger } from '../../utils/logger';
+const logger_1 = require("../../../utils/logger");
 const socket_utils_1 = require("../../../daemon/socket-utils");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
 const installation_directory_1 = require("../../../utils/installation-directory");
@@ -116,6 +115,7 @@ function createWorkerHandler(worker, pending, onload, onloadError, socket) {
                     const { name, createNodesPattern, include, exclude } = result;
                     pluginName = name;
                     pluginNames.set(worker, pluginName);
+                    logger_1.logger.verbose(`[plugin-pool] loaded plugin "${name}" from worker (pid: ${worker.pid})`);
                     onload({
                         name,
                         include,
@@ -298,6 +298,7 @@ function registerPendingPromise(tx, pending, callback, context) {
 }
 global.nxPluginWorkerCount ??= 0;
 async function startPluginWorker(name) {
+    performance.mark(`start-plugin-worker:${name}`);
     // this should only really be true when running unit tests within
     // the Nx repo. We still need to start the worker in this case,
     // but its typescript.
@@ -325,6 +326,7 @@ async function startPluginWorker(name) {
         shell: false,
         windowsHide: true,
     });
+    logger_1.logger.verbose(`[plugin-pool] spawned worker for "${name}" (pid: ${worker.pid}, socket: ${ipcPath})`);
     // To make debugging easier and allow plugins to communicate things
     // like performance metrics, we pipe the stdout/stderr of the worker
     // to the main process.
@@ -343,32 +345,11 @@ async function startPluginWorker(name) {
     if (stderrMaxListeners !== 0) {
         process.stderr.setMaxListeners(stderrMaxListeners + 1);
     }
-    worker.stdout.pipe(process.stdout);
-    worker.stderr.pipe(process.stderr);
+    // Pipe and unref the worker streams. The utility handles cross-runtime compatibility.
+    pipeAndUnrefChildStream(worker.stdout, process.stdout, 'stdout');
+    pipeAndUnrefChildStream(worker.stderr, process.stderr, 'stderr');
     // Unref the worker process so it doesn't prevent the parent from exiting.
-    // IMPORTANT: We must also unref the stdout/stderr streams. When streams are
-    // piped, they maintain internal references in Node's event loop. Without
-    // unreferencing them, the parent process will wait for the worker to exit
-    // even after worker.unref() is called. This causes e2e tests to hang on CI
-    // where test frameworks wait for all handles to be released.
-    //
-    // Although TypeScript types these as Readable/Writable, they are actually
-    // net.Socket instances at runtime. Node.js internally creates sockets for
-    // stdio pipes (see lib/internal/child_process.js createSocket function).
-    // Socket.unref() allows the event loop to exit if these are the only handles.
     worker.unref();
-    if (worker.stdout instanceof net_1.Socket) {
-        worker.stdout.unref();
-    }
-    else {
-        throw new Error(`Expected worker.stdout to be an instance of Socket, but got ${getTypeName(worker.stdout)}`);
-    }
-    if (worker.stderr instanceof net_1.Socket) {
-        worker.stderr.unref();
-    }
-    else {
-        throw new Error(`Expected worker.stderr to be an instance of Socket, but got ${getTypeName(worker.stderr)}`);
-    }
     let attempts = 0;
     return new Promise((resolve, reject) => {
         const id = setInterval(async () => {
@@ -376,6 +357,7 @@ async function startPluginWorker(name) {
             if (socket) {
                 socket.unref();
                 clearInterval(id);
+                logger_1.logger.verbose(`[plugin-pool] connected to worker for "${name}" (pid: ${worker.pid}) after ${attempts} attempt(s)`);
                 resolve({
                     worker,
                     socket,
@@ -384,12 +366,16 @@ async function startPluginWorker(name) {
             else if (attempts > 10000) {
                 // daemon fails to start, the process probably exited
                 // we print the logs and exit the client
-                reject('Failed to start plugin worker.');
+                clearInterval(id);
+                reject(new Error(`Failed to start plugin worker for plugin ${name}`));
             }
             else {
                 attempts++;
             }
         }, 10);
+    }).finally(() => {
+        performance.mark(`start-plugin-worker-end:${name}`);
+        performance.measure(`start-plugin-worker:${name}`, `start-plugin-worker:${name}`, `start-plugin-worker-end:${name}`);
     });
 }
 function isServerAvailable(ipcPath) {
@@ -420,3 +406,68 @@ function getTypeName(u) {
     }
     return u.constructor?.name ?? 'unknown object';
 }
+/**
+ * Detects if we're running under an alternative JavaScript runtime (Bun or Deno).
+ * Returns the runtime name for helpful error messages, or null if running on Node.js.
+ */
+function detectAlternativeRuntime() {
+    // Check for Bun runtime - the Bun global is only available in Bun
+    if ('Bun' in globalThis && typeof globalThis.Bun !== 'undefined') {
+        return 'bun';
+    }
+    // Check for Deno runtime - the Deno global is only available in Deno
+    if ('Deno' in globalThis && typeof globalThis.Deno !== 'undefined') {
+        return 'deno';
+    }
+    return null;
+}
+/**
+ * Pipes a child process stream to a destination and attempts to unref it to prevent
+ * the stream from keeping the parent process alive.
+ *
+ * In Node.js, child process stdio streams are actually net.Socket instances when
+ * using 'pipe' stdio option. However, alternative runtimes like Bun and Deno may
+ * use standard Readable/Writable streams instead.
+ *
+ * This function:
+ * 1. Pipes the source to the destination
+ * 2. Attempts to unref the source stream to allow the parent process to exit
+ * 3. Uses duck-typing to check for unref support when not a Socket instance
+ * 4. Emits helpful warnings for alternative runtimes if unref is not available
+ *
+ * @param source - The child process stream (stdout or stderr)
+ * @param destination - The process stream to pipe to (process.stdout or process.stderr)
+ * @param streamName - Name of the stream for warning messages ('stdout' or 'stderr')
+ */
+function pipeAndUnrefChildStream(source, destination, streamName) {
+    if (!source) {
+        return;
+    }
+    source.pipe(destination);
+    // Node.js creates net.Socket instances for stdio pipes. Use instanceof check first.
+    if (source instanceof net_1.Socket) {
+        source.unref();
+        return;
+    }
+    // For non-Socket streams (e.g., in Bun/Deno), use duck-typing to check for unref
+    // NOTE: These should also be a Socket, but alternative runtimes may implement differently...
+    // See:
+    // - https://github.com/denoland/deno/issues/31961
+    // - https://github.com/oven-sh/bun/issues/26505
+    if (typeof source.unref === 'function') {
+        source.unref();
+        return;
+    }
+    // Stream doesn't support unref - emit a warning with runtime-specific guidance
+    const runtime = detectAlternativeRuntime();
+    if (runtime) {
+        console.warn(`[NX] worker.${streamName} does not support unref() in ${runtime}. ` +
+            `This may cause the process to hang when waiting for plugin workers to exit. ` +
+            `This is a known limitation of ${runtime}'s Node.js compatibility layer.`);
+    }
+    else {
+        console.warn(`[NX] worker.${streamName} is not a net.Socket and does not have an unref() method. ` +
+            `Expected Socket, got ${getTypeName(source)}. ` +
+            `This may cause the process to hang when waiting for plugin workers to exit.`);
+    }
+}

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -2,30 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_perf_hooks_1 = require("node:perf_hooks");
 node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- start`);
-const messaging_1 = require("./messaging");
-const serializable_error_1 = require("../../../utils/serializable-error");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
-const net_1 = require("net");
+const logger_1 = require("../../../utils/logger");
+const serializable_error_1 = require("../../../utils/serializable-error");
+const messaging_1 = require("./messaging");
 const fs_1 = require("fs");
-if (process.env.NX_PERF_LOGGING === 'true') {
+const net_1 = require("net");
+const environment = process.env;
+if (environment.NX_PERF_LOGGING === 'true') {
     require('../../../utils/perf-logging');
 }
 node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- end`);
 node_perf_hooks_1.performance.measure(`plugin worker ${process.pid} code loading`, `plugin worker ${process.pid} code loading -- start`, `plugin worker ${process.pid} code loading -- end`);
 global.NX_GRAPH_CREATION = true;
 global.NX_PLUGIN_WORKER = true;
-let connected = false;
 let plugin;
 const socketPath = process.argv[2];
+const expectedPluginName = process.argv[3];
+let connectErrorTimeout = setErrorTimeout(5000, `The plugin worker for ${expectedPluginName} is exiting as it was not connected to within 5 seconds. ` +
+    'Plugin workers expect to receive a socket connection from the parent process shortly after being started. ' +
+    'If you are seeing this issue, please report it to the Nx team at https://github.com/nrwl/nx/issues.');
 const server = (0, net_1.createServer)((socket) => {
-    connected = true;
+    connectErrorTimeout?.clear();
+    logger_1.logger.verbose(`[plugin-worker] "${expectedPluginName}" (pid: ${process.pid}) connected`);
     // This handles cases where the host process was killed
     // after the worker connected but before the worker was
     // instructed to load the plugin.
-    const loadTimeout = setTimeout(() => {
-        console.error(`Plugin Worker exited because no plugin was loaded within 10 seconds of starting up.`);
-        process.exit(1);
-    }, 10000).unref();
+    let loadErrorTimeout = setErrorTimeout(10_000, `Plugin Worker for ${expectedPluginName} is exiting as it did not receive a load message within 10 seconds of connecting. ` +
+        'This likely indicates that the host process was terminated before the worker could be instructed to load the plugin. ' +
+        'If you are seeing this issue, please report it to the Nx team at https://github.com/nrwl/nx/issues.');
     socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)((raw) => {
         const message = JSON.parse(raw.toString());
         if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
@@ -33,8 +38,7 @@ const server = (0, net_1.createServer)((socket) => {
         }
         return (0, messaging_1.consumeMessage)(socket, message, {
             load: async ({ plugin: pluginConfiguration, root, name, pluginPath, shouldRegisterTSTranspiler, }) => {
-                if (loadTimeout)
-                    clearTimeout(loadTimeout);
+                loadErrorTimeout?.clear();
                 process.chdir(root);
                 try {
                     const { loadResolvedNxPluginAsync } = await Promise.resolve().then(() => require('../load-resolved-plugin'));
@@ -44,6 +48,7 @@ const server = (0, net_1.createServer)((socket) => {
                         require('../transpiler').registerPluginTSTranspiler();
                     }
                     plugin = await loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name);
+                    logger_1.logger.verbose(`[plugin-worker] "${name}" (pid: ${process.pid}) loaded successfully`);
                     return {
                         type: 'load-result',
                         payload: {
@@ -186,13 +191,24 @@ const server = (0, net_1.createServer)((socket) => {
     });
 });
 server.listen(socketPath);
-if (process.env.NX_PLUGIN_NO_TIMEOUTS !== 'true') {
-    setTimeout(() => {
-        if (!connected) {
-            console.error('The plugin worker is exiting as it was not connected to within 5 seconds.');
+logger_1.logger.verbose(`[plugin-worker] "${expectedPluginName}" (pid: ${process.pid}) listening on ${socketPath}`);
+function setErrorTimeout(timeoutMs, errorMessage) {
+    if (environment.NX_PLUGIN_NO_TIMEOUTS === 'true') {
+        return;
+    }
+    let cleared = false;
+    const timeout = setTimeout(() => {
+        if (!cleared) {
+            console.error(errorMessage);
             process.exit(1);
         }
-    }, 5000).unref();
+    }, timeoutMs).unref();
+    return {
+        clear: () => {
+            cleared = true;
+            clearTimeout(timeout);
+        },
+    };
 }
 const exitHandler = (exitCode) => () => {
     server.close();

package/src/project-graph/project-graph.js

@@ -40,7 +40,7 @@ function readCachedProjectGraph(minimumComputedAt) {
             ? (0, strip_indents_1.stripIndents) `
       Make sure invoke 'node ./decorate-angular-cli.js' in your postinstall script.
       The decorated CLI will compute the project graph.
-      'ng --help' should say 'Smart Repos · Fast Builds'.
+      'ng --help' should say 'Smart Monorepos · Fast Builds'.
       `
             : '';
         throw new Error((0, strip_indents_1.stripIndents) `

package/src/utils/consume-messages-from-socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consume-messages-from-socket.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/consume-messages-from-socket.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,QACuB,CAAC;AAEpD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,IAEnE,SAAI,UA4Bb;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAYtD"}
+{"version":3,"file":"consume-messages-from-socket.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/consume-messages-from-socket.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe,QACuB,CAAC;AAEpD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,IAGnE,SAAI,UA4Bb;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAYtD"}

package/src/utils/consume-messages-from-socket.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MESSAGE_END_SEQ = void 0;
 exports.consumeMessagesFromSocket = consumeMessagesFromSocket;
 exports.isJsonMessage = isJsonMessage;
+const string_decoder_1 = require("string_decoder");
 const VERY_END_CODE = 4;
 exports.MESSAGE_END_SEQ = 'NX_MSG_END' + String.fromCharCode(VERY_END_CODE);
 function consumeMessagesFromSocket(callback) {
     let message = '';
+    const decoder = new string_decoder_1.StringDecoder('utf8');
     return (data) => {
-        const chunk = data.toString();
+        const chunk = decoder.write(data);
         message += chunk;
         // Check if accumulated message ends with MESSAGE_END_SEQ (not just the chunk)
         // This handles TCP packet fragmentation where MESSAGE_END_SEQ may be split across packets

package/src/utils/promised-based-queue.d.ts

@@ -3,12 +3,5 @@ export declare class PromisedBasedQueue {
     private promise;
     sendToQueue(fn: () => Promise<any>): Promise<any>;
     isEmpty(): boolean;
-    /**
-     * Used to decrement the internal counter representing the number of active promises in the queue.
-     * This is useful for retrying a failed daemon message, as we want to be able to shut the daemon down
-     * without marking the promise that represents the failed message as settled. To do so, we store
-     * the promise in a separate variable and only resolve or reject it later.
-     */
-    decrementQueueCounter(): void;
 }
 //# sourceMappingURL=promised-based-queue.d.ts.map

package/src/utils/promised-based-queue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"promised-based-queue.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/promised-based-queue.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAyB;IAExC,WAAW,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC;IA8BjD,OAAO;IAIP;;;;;OAKG;IACH,qBAAqB;CAGtB"}
+{"version":3,"file":"promised-based-queue.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/promised-based-queue.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAyB;IAExC,WAAW,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC;IA8BjD,OAAO;CAGR"}

package/src/utils/promised-based-queue.js

@@ -39,14 +39,5 @@ class PromisedBasedQueue {
     isEmpty() {
         return this.counter === 0;
     }
-    /**
-     * Used to decrement the internal counter representing the number of active promises in the queue.
-     * This is useful for retrying a failed daemon message, as we want to be able to shut the daemon down
-     * without marking the promise that represents the failed message as settled. To do so, we store
-     * the promise in a separate variable and only resolve or reject it later.
-     */
-    decrementQueueCounter() {
-        this.counter--;
-    }
 }
 exports.PromisedBasedQueue = PromisedBasedQueue;