nx 22.7.11 → 22.7.12

package/dist/src/daemon/socket-utils.js

@@ -4,7 +4,9 @@ exports.getPluginOsSocketPath = exports.getForkedProcessOsSocketPath = exports.g
 exports.getPluginSocketFileName = getPluginSocketFileName;
 exports.killSocketOrPath = killSocketOrPath;
 exports.serializeResult = serializeResult;
+exports.serializeWithFallback = serializeWithFallback;
 exports.serialize = serialize;
+exports.sendMessage = sendMessage;
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -12,6 +14,7 @@ const tmp_dir_1 = require("./tmp-dir");
 const serializable_error_1 = require("../utils/serializable-error");
 const is_v8_serializer_enabled_1 = require("./is-v8-serializer-enabled");
 const v8_1 = require("v8");
+const consume_messages_from_socket_1 = require("../utils/consume-messages-from-socket");
 exports.isWindows = (0, os_1.platform)() === 'win32';
 /**
  * For IPC with the daemon server we use unix sockets or windows named pipes, depending on the user's operating system.
@@ -77,41 +80,52 @@ function serializeResult(error, serializedProjectGraph, serializedSourceMaps) {
     // We do not want to repeat work `JSON.stringify`ing an object containing the potentially large project graph so merge as strings
     return `{ "error": ${JSON.stringify(error ? (0, serializable_error_1.createSerializableError)(error) : error)}, "projectGraph": ${serializedProjectGraph}, "sourceMaps": ${serializedSourceMaps} }`;
 }
+function serializeAs(data, format) {
+    return format === 'v8'
+        ? (0, v8_1.serialize)(data)
+        : Buffer.from(JSON.stringify(data), 'utf8');
+}
 /**
- * Helper to serialize data either using v8 serialization or JSON serialization, based on
- * the user's preference and the success of each method. Should only be used by "client" side
- * connections, daemon or other servers should respond based on the type of serialization used
- * by the client it is communicating with.
+ * Serialize using `preferred`, falling back to the other format when it throws.
+ * Neither format subsumes the other: JSON cannot represent a BigInt and hits the
+ * max string length far sooner, while v8 cannot clone a function.
  *
  * @param data Data to serialize
- * @param force Forces one serialization method over the other
- * @returns Serialized data as a string
+ * @param preferred Format to attempt first
+ * @returns Serialized data as bytes ready to be framed onto a socket
  */
-function serialize(data, force) {
-    if (force === 'v8' || (0, is_v8_serializer_enabled_1.isV8SerializerEnabled)()) {
-        try {
-            return (0, v8_1.serialize)(data).toString('binary');
-        }
-        catch (e) {
-            if (force !== 'v8') {
-                console.warn(`Data could not be serialized using v8 serialization: ${e}. Falling back to JSON serialization.`);
-                // Fall back to JSON serialization
-                return JSON.stringify(data);
-            }
-            throw e;
-        }
+function serializeWithFallback(data, preferred) {
+    try {
+        return serializeAs(data, preferred);
     }
-    else {
-        try {
-            return JSON.stringify(data);
-        }
-        catch (e) {
-            if (force !== 'json') {
-                // Fall back to v8 serialization
-                console.warn(`Data could not be serialized using JSON.stringify: ${e}. Falling back to v8 serialization.`);
-                return (0, v8_1.serialize)(data).toString('binary');
-            }
-            throw e;
-        }
+    catch (e) {
+        const fallback = preferred === 'v8' ? 'json' : 'v8';
+        console.warn(`Data could not be serialized using ${preferred} serialization: ${e}. Falling back to ${fallback} serialization.`);
+        return serializeAs(data, fallback);
     }
 }
+/**
+ * Serialize data for IPC using the format the user configured.
+ *
+ * @param data Data to serialize
+ * @param force Use this format without falling back. For callers whose data is
+ *              known to be unrepresentable in the other format, where a fallback
+ *              would only swap one failure for a less obvious one.
+ * @returns Serialized data as bytes ready to be framed onto a socket
+ */
+function serialize(data, force) {
+    return force
+        ? serializeAs(data, force)
+        : serializeWithFallback(data, (0, is_v8_serializer_enabled_1.isV8SerializerEnabled)() ? 'v8' : 'json');
+}
+/**
+ * Serialize `data` and write it as one framed message.
+ *
+ * Lives here rather than in `writeMessage` so the framing stays a byte-level
+ * primitive: `utils/consume-messages-from-socket` is shared by callers that
+ * already hold bytes, and having it reach back into the daemon's serializer
+ * would invert the dependency.
+ */
+function sendMessage(socket, data, force, callback) {
+    (0, consume_messages_from_socket_1.writeMessage)(socket, serialize(data, force), callback);
+}

package/dist/src/hasher/create-task-hasher.js

@@ -9,7 +9,7 @@ function createTaskHasher(projectGraph, nxJson, runnerOptions) {
         return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions);
     }
     else {
-        const { fileMap, allWorkspaceFiles, rustReferences } = (0, build_project_graph_1.getFileMap)();
+        const { rustReferences } = (0, build_project_graph_1.getFileMap)();
         return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
     }
 }

package/dist/src/project-graph/build-project-graph.d.ts

@@ -2,18 +2,16 @@ import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/proje
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
 import { CreateMetadataError } from './error-types';
-import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
 import { CreateMetadataContext } from './plugins';
 import type { LoadedNxPlugin } from './plugins/loaded-nx-plugin';
 import type { ConfigurationSourceMaps } from './utils/project-configuration/source-maps';
 export declare function getFileMap(): {
     fileMap: FileMap;
-    allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals | null;
 };
-export declare function hydrateFileMap(fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals): void;
-export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
+export declare function hydrateFileMap(fileMap: FileMap, rustReferences: NxWorkspaceFilesExternals): void;
+export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;
 }>;

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

@@ -23,13 +23,11 @@ const implicit_project_dependencies_1 = require("./utils/implicit-project-depend
 const normalize_project_nodes_1 = require("./utils/normalize-project-nodes");
 const target_merging_1 = require("./utils/project-configuration/target-merging");
 let storedFileMap = null;
-let storedAllWorkspaceFiles = null;
 let storedRustReferences = null;
 function getFileMap() {
     if (!!storedFileMap) {
         return {
             fileMap: storedFileMap,
-            allWorkspaceFiles: storedAllWorkspaceFiles,
             rustReferences: storedRustReferences,
         };
     }
@@ -39,19 +37,16 @@ function getFileMap() {
                 nonProjectFiles: [],
                 projectFileMap: {},
             },
-            allWorkspaceFiles: [],
             rustReferences: null,
         };
     }
 }
-function hydrateFileMap(fileMap, allWorkspaceFiles, rustReferences) {
+function hydrateFileMap(fileMap, rustReferences) {
     storedFileMap = fileMap;
-    storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
 }
-async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins, sourceMap) {
+async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, rustReferences, fileMapCache, plugins, sourceMap) {
     storedFileMap = fileMap;
-    storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
     const projects = {};
     for (const root in projectRootMap) {

package/dist/src/project-graph/file-map-utils.d.ts

@@ -1,8 +1,7 @@
-import { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
-import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import type { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
+import type { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
 export interface WorkspaceFileMap {
-    allWorkspaceFiles: FileData[];
     fileMap: FileMap;
 }
 export declare function createProjectFileMapUsingProjectGraph(graph: ProjectGraph): Promise<ProjectFileMap>;
@@ -10,6 +9,5 @@ export declare function createFileMapUsingProjectGraph(graph: ProjectGraph): Pro
 export declare function createFileMap(projectsConfigurations: ProjectsConfigurations, allWorkspaceFiles: FileData[]): WorkspaceFileMap;
 export declare function updateFileMap(projectsConfigurations: Record<string, ProjectConfiguration>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): {
     fileMap: import("../native").FileMap;
-    allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals;
 };

package/dist/src/project-graph/file-map-utils.js

@@ -7,7 +7,6 @@ exports.updateFileMap = updateFileMap;
 const workspace_context_1 = require("../utils/workspace-context");
 const workspace_root_1 = require("../utils/workspace-root");
 const project_graph_1 = require("./project-graph");
-const build_all_workspace_files_1 = require("./utils/build-all-workspace-files");
 const find_project_for_path_1 = require("./utils/find-project-for-path");
 async function createProjectFileMapUsingProjectGraph(graph) {
     return (await createFileMapUsingProjectGraph(graph)).fileMap.projectFileMap;
@@ -38,7 +37,6 @@ function createFileMap(projectsConfigurations, allWorkspaceFiles) {
         }
     }
     return {
-        allWorkspaceFiles,
         fileMap: {
             projectFileMap,
             nonProjectFiles,
@@ -49,7 +47,6 @@ function updateFileMap(projectsConfigurations, rustReferences, updatedFiles, del
     const updates = (0, workspace_context_1.updateProjectFiles)(Object.fromEntries((0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations)), rustReferences, updatedFiles, deletedFiles);
     return {
         fileMap: updates.fileMap,
-        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(updates.fileMap.projectFileMap, updates.fileMap.nonProjectFiles),
         rustReferences: updates.externalReferences,
     };
 }

package/dist/src/project-graph/plugins/isolation/isolated-plugin.js

@@ -52,7 +52,17 @@ class IsolatedPlugin {
         this.responseHandlers = new Map();
         this.exitHandler = null;
         this.handleSocketData = (raw) => {
-            const message = (0, consume_messages_from_socket_1.parseMessage)(raw);
+            let message;
+            try {
+                message = (0, consume_messages_from_socket_1.parseMessage)(raw);
+            }
+            catch (e) {
+                // Runs inside a synchronous socket 'data' callback, so a throw here
+                // becomes an uncaughtException in the host process rather than a failed
+                // plugin call.
+                logger_2.logger.error(`[plugin-client] "${this.name}" sent a message that could not be parsed: ${e instanceof Error ? e.message : e}\nReceived: ${(0, consume_messages_from_socket_1.describeMessage)(raw)}`);
+                return;
+            }
             if ((0, messaging_1.isPluginWorkerNotification)(message)) {
                 handlePluginWorkerNotification(message);
                 return;
@@ -94,7 +104,13 @@ class IsolatedPlugin {
             this.responseHandlers.clear();
         };
         worker.on('exit', this.exitHandler);
-        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(this.handleSocketData));
+        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(this.handleSocketData, (err) => {
+            // Nothing else settles the pending hook promises on a framing
+            // failure, so surface it the same way a dead worker would.
+            this.exitHandler?.();
+            socket.destroy();
+            console.error(err.message);
+        }));
         return this.sendLoadMessage();
     }
     /**

package/dist/src/project-graph/plugins/isolation/messaging.js

@@ -6,7 +6,6 @@ exports.isPluginWorkerResult = isPluginWorkerResult;
 exports.consumeMessage = consumeMessage;
 exports.sendMessageOverSocket = sendMessageOverSocket;
 const socket_utils_1 = require("../../../daemon/socket-utils");
-const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const NOTIFICATION_TYPES = [
     'emitLog',
@@ -84,6 +83,5 @@ async function consumeMessage(socket, raw, handlers) {
 function sendMessageOverSocket(socket, message) {
     // Stamped here rather than in each constructor, mirroring the daemon.
     message.workspaceRoot = workspace_root_1.workspaceRoot;
-    socket.write((0, socket_utils_1.serialize)(message));
-    socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+    (0, socket_utils_1.sendMessage)(socket, message);
 }

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

@@ -87,7 +87,8 @@ const server = (0, net_1.createServer)((socket) => {
                         exclude: plugin.exclude,
                         createNodesPattern: plugin.createNodes?.[0],
                         hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
-                        hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,
+                        hasProcessProjectGraph: 'processProjectGraph' in plugin &&
+                            !!plugin.processProjectGraph,
                         hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
                         hasPreTasksExecution: 'preTasksExecution' in plugin && !!plugin.preTasksExecution,
                         hasPostTasksExecution: 'postTasksExecution' in plugin && !!plugin.postTasksExecution,
@@ -118,6 +119,13 @@ const server = (0, net_1.createServer)((socket) => {
                 }
             }),
         });
+    }, (err) => {
+        // The host link cannot resynchronize. Exit so the host's 'exit' handler
+        // rejects the pending hooks instead of waiting on a reply that the
+        // framing failure guarantees will never arrive.
+        console.error(err.message);
+        socket.destroy();
+        process.exit(1);
     }));
     // When the host disconnects, clean up and exit.
     socket.on('end', () => {

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

@@ -104,14 +104,14 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     const { projects, externalNodes, sourceMaps, projectRootMap } = configurationResult;
     perf_hooks_1.performance.mark('retrieve-project-configurations:end');
     perf_hooks_1.performance.mark('retrieve-workspace-files:start');
-    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    const { fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
     perf_hooks_1.performance.mark('retrieve-workspace-files:end');
     const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
     let projectGraphError;
     let projectGraphResult;
     try {
-        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
     }
     catch (e) {
         if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
@@ -180,8 +180,8 @@ async function readCachedGraphAndHydrateFileMap(minimumComputedAt) {
         data.root,
         project,
     ]));
-    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
-    (0, build_project_graph_1.hydrateFileMap)(fileMap, allWorkspaceFiles, rustReferences);
+    const { fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    (0, build_project_graph_1.hydrateFileMap)(fileMap, rustReferences);
     return graph;
 }
 /**

package/dist/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -3,13 +3,12 @@ import { NxJsonConfiguration } from '../../config/nx-json';
 import { ConfigurationResult } from './project-configuration-utils';
 import type { LoadedNxPlugin } from '../plugins/loaded-nx-plugin';
 /**
- * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
+ * Walks the workspace directory to create the `projectFileMap` and `ProjectConfigurations`
  * @throws
  * @param workspaceRoot
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: Record<string, import("../../native").FileData[]>;
         nonProjectFiles: import("../../native").FileData[];

package/dist/src/project-graph/utils/retrieve-workspace-files.js

@@ -11,11 +11,10 @@ const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
 const project_configuration_utils_1 = require("./project-configuration-utils");
 const workspace_context_1 = require("../../utils/workspace-context");
-const build_all_workspace_files_1 = require("./build-all-workspace-files");
 const path_1 = require("path");
 const get_plugins_1 = require("../plugins/get-plugins");
 /**
- * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
+ * Walks the workspace directory to create the `projectFileMap` and `ProjectConfigurations`
  * @throws
  * @param workspaceRoot
  * @param nxJson
@@ -29,7 +28,6 @@ async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
     perf_hooks_1.performance.mark('get-workspace-files:end');
     perf_hooks_1.performance.measure('get-workspace-files', 'get-workspace-files:start', 'get-workspace-files:end');
     return {
-        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(projectFileMap, globalFiles),
         fileMap: {
             projectFileMap,
             nonProjectFiles: globalFiles,

package/dist/src/tasks-runner/pseudo-ipc.js

@@ -77,6 +77,14 @@ class PseudoIPCServer {
                     this.childReadyMap.get(childId)();
                 }
             }
+        }, 
+        // Nothing resynchronizes a length-prefixed stream, so report it the
+        // same way a socket error is reported and let the peer see the close.
+        (err) => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onError?.(err);
+            }
+            socket.destroy();
         }));
         socket.on('close', () => {
             for (const childMessage of this.childMessages) {
@@ -91,15 +99,12 @@ class PseudoIPCServer {
     }
     sendMessageToChildren(message) {
         this.sockets.forEach((socket) => {
-            socket.write((0, socket_utils_1.serialize)({ type: 'TO_CHILDREN_FROM_PARENT', message }));
-            // send EOT to indicate that the message has been fully written
-            socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+            (0, socket_utils_1.sendMessage)(socket, { type: 'TO_CHILDREN_FROM_PARENT', message });
         });
     }
     sendMessageToChild(id, message) {
         this.sockets.forEach((socket) => {
-            socket.write((0, socket_utils_1.serialize)({ type: 'TO_CHILDREN_FROM_PARENT', id, message }));
-            socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+            (0, socket_utils_1.sendMessage)(socket, { type: 'TO_CHILDREN_FROM_PARENT', id, message });
         });
     }
     onMessageFromChildren(onMessage, onClose = () => { }, onError = (err) => { }) {
@@ -121,17 +126,13 @@ class PseudoIPCClient {
         this.socket = (0, net_1.connect)(this.path);
     }
     sendMessageToParent(message) {
-        this.socket.write((0, socket_utils_1.serialize)({ type: 'TO_PARENT_FROM_CHILDREN', message }));
-        // send EOT to indicate that the message has been fully written
-        this.socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+        (0, socket_utils_1.sendMessage)(this.socket, { type: 'TO_PARENT_FROM_CHILDREN', message });
     }
     notifyChildIsReady(id) {
-        this.socket.write((0, socket_utils_1.serialize)({
+        (0, socket_utils_1.sendMessage)(this.socket, {
             type: 'CHILD_READY',
             message: id,
-        }));
-        // send EOT to indicate that the message has been fully written
-        this.socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+        });
     }
     onMessageFromParent(forkId, onMessage, onClose = () => { }, onError = (err) => { }) {
         this.socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
@@ -144,7 +145,7 @@ class PseudoIPCClient {
                     onMessage(message);
                 }
             }
-        }));
+        }, onError));
         this.socket.on('close', onClose);
         this.socket.on('error', onError);
         return this;

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

@@ -1,9 +1,44 @@
-export declare const MESSAGE_END_SEQ: string;
-export declare function consumeMessagesFromSocket(callback: (message: string) => void): (data: any) => void;
-export declare function isJsonMessage(message: string): boolean;
+import type { Socket } from 'net';
+export declare const MESSAGE_HEADER_PREFIX = "NX_MSG_";
 /**
- * Parse a message that was produced by `serialize()` in
- * `daemon/socket-utils.ts`. Auto-detects JSON vs. v8-serialized payloads using
- * `isJsonMessage()` and decodes the binary path via `v8.deserialize`.
+ * Ceiling on a single message, in bytes. Payloads are buffered outside the V8
+ * heap, so `--max-old-space-size` does not bound them and a peer that declares
+ * a huge length would otherwise be allowed to stream until the machine gives
+ * out. The default is four times the ~0.5GiB string ceiling that used to cap
+ * every message, so it clears any payload that previously worked or was meant
+ * to. Set `NX_MAX_MESSAGE_SIZE` to another byte count to change it, or to 0 to
+ * remove the ceiling. The daemon reads it from the env it was spawned with —
+ * clients do not reflect it (see DAEMON_ENV_VARS_EXCLUSIONS) — so changing it
+ * needs a daemon restart (`nx reset`).
  */
-export declare function parseMessage<T = unknown>(message: string): T;
+export declare const DEFAULT_MAX_MESSAGE_SIZE: number;
+export declare function getMaxMessageSize(): number;
+export declare function frameHeader(payloadLength: number): Buffer;
+/**
+ * Writes a length-prefixed message. The header and payload are written
+ * separately so a large payload is never copied to prepend its header.
+ */
+export declare function writeMessage(socket: Socket, payload: Buffer, callback?: (err?: Error) => void): void;
+export declare class MessageFramingError extends Error {
+    constructor(message: string);
+}
+export declare function consumeMessagesFromSocket(callback: (message: Buffer) => void, onError?: (error: MessageFramingError) => void): (data: Buffer) => void;
+/**
+ * v8-serialized payloads always begin with the 0xFF version header, which no
+ * JSON document can start with.
+ */
+export declare function isJsonMessage(message: Buffer): boolean;
+/**
+ * Render part of a message for an error message. A v8 payload is binary rather
+ * than utf8 text — its 0xFF header alone can never decode — so it is rendered
+ * as hex instead of as U+FFFD-riddled mojibake.
+ */
+export declare function describeMessage(message: Buffer, { maxBytes, from }?: DescribeMessageOptions): string;
+export interface DescribeMessageOptions {
+    maxBytes?: number;
+    from?: 'start' | 'end';
+}
+/**
+ * Parse a message produced by `serialize()` in `daemon/socket-utils.ts`.
+ */
+export declare function parseMessage<T = unknown>(message: Buffer): T;