nx 18.4.0-canary.20240418-e549ea2 → 19.0.0-beta.1

package/src/daemon/server/server.js

@@ -60,10 +60,7 @@ async function handleMessage(socket, data) {
         await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `File watcher error in the workspace '${workspace_root_1.workspaceRoot}'.`, workspaceWatcherError);
     }
     if (daemonIsOutdated()) {
-        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Lock files changed`, {
-            name: '',
-            message: 'LOCK-FILES-CHANGED',
-        });
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Lock files changed`, new Error('LOCK-FILES-CHANGED'));
     }
     (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
     const unparsedPayload = data;

package/src/daemon/socket-utils.js

@@ -5,7 +5,7 @@ const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const tmp_dir_1 = require("./tmp-dir");
-const error_types_1 = require("../project-graph/error-types");
+const serializable_error_1 = require("../utils/serializable-error");
 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.
@@ -28,21 +28,9 @@ function killSocketOrPath() {
     catch { }
 }
 exports.killSocketOrPath = killSocketOrPath;
-// Include the original stack trace within the serialized error so that the client can show it to the user.
-function serializeError(error) {
-    if (!error) {
-        return null;
-    }
-    if (error instanceof error_types_1.DaemonProjectGraphError) {
-        error.errors = error.errors.map((e) => JSON.parse(serializeError(e)));
-    }
-    return `{${Object.getOwnPropertyNames(error)
-        .map((k) => `"${k}": ${JSON.stringify(error[k])}`)
-        .join(',')}}`;
-}
 // Prepare a serialized project graph result for sending over IPC from the server to the client
 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": ${serializeError(error)}, "projectGraph": ${serializedProjectGraph}, "sourceMaps": ${serializedSourceMaps} }`;
+    return `{ "error": ${JSON.stringify(error ? (0, serializable_error_1.createSerializableError)(error) : error)}, "projectGraph": ${serializedProjectGraph}, "sourceMaps": ${serializedSourceMaps} }`;
 }
 exports.serializeResult = serializeResult;

package/src/executors/run-commands/run-commands.impl.js

@@ -8,6 +8,16 @@ const npm_run_path_1 = require("npm-run-path");
 const chalk = require("chalk");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 exports.LARGE_BUFFER = 1024 * 1000000;
+const exitListeners = new Set();
+function processExitListener() {
+    for (const listener of exitListeners) {
+        listener();
+    }
+}
+process.on('exit', processExitListener);
+process.on('SIGTERM', processExitListener);
+process.on('SIGINT', processExitListener);
+process.on('SIGQUIT', processExitListener);
 async function loadEnvVars(path) {
     if (path) {
         const result = (await Promise.resolve().then(() => require('dotenv'))).config({ path });
@@ -205,11 +215,8 @@ function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
         /**
          * Ensure the child process is killed when the parent exits
          */
-        const processExitListener = (signal) => childProcess.kill(signal);
-        process.on('exit', processExitListener);
-        process.on('SIGTERM', processExitListener);
-        process.on('SIGINT', processExitListener);
-        process.on('SIGQUIT', processExitListener);
+        const childProcessKiller = (signal) => childProcess.kill(signal);
+        exitListeners.add(childProcessKiller);
         childProcess.stdout.on('data', (data) => {
             const output = addColorAndPrefix(data, commandConfig);
             terminalOutput += output;
@@ -239,6 +246,7 @@ function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
             res({ success: false, terminalOutput });
         });
         childProcess.on('exit', (code) => {
+            exitListeners.delete(childProcessKiller);
             if (!readyWhen) {
                 res({ success: code === 0, terminalOutput });
             }

package/src/native/index.d.ts

@@ -29,11 +29,8 @@ export function findImports(projectFileMap: Record<string, Array<string>>): Arra
  * This wont be needed once the project graph is created in Rust
  */
 export function transferProjectGraph(projectGraph: ProjectGraph): ExternalObject<ProjectGraph>
-export interface ExternalNodeData {
-  version: string
-  hash?: string
-}
 export interface ExternalNode {
+  packageName?: string
   version: string
   hash?: string
 }

package/src/native/index.js

@@ -1,8 +1,8 @@
-const { join,  basename } = require('path');
+const { join, basename } = require('path');
 const { copyFileSync, existsSync, mkdirSync } = require('fs');
 const Module = require('module');
-const { nxVersion} = require("../utils/versions")
-const { cacheDir} = require("../utils/cache-directory")
+const { nxVersion } = require('../utils/versions');
+const { cacheDir } = require('../utils/cache-directory');
 
 const nxPackages = new Set([
   '@nx/nx-android-arm64',
@@ -40,7 +40,7 @@ const localNodeFiles = [
 
 const originalLoad = Module._load;
 
-// We override the _load function so that when a native file is required, 
+// We override the _load function so that when a native file is required,
 // we copy it to a cache directory and require it from there.
 // This prevents the file being loaded from node_modules and causing file locking issues.
 // Will only be called once because the require cache takes over afterwards.
@@ -51,7 +51,7 @@ Module._load = function (request, parent, isMain) {
     localNodeFiles.some((f) => modulePath.endsWith(f))
   ) {
     const nativeLocation = require.resolve(modulePath);
-    const fileName = basename(nativeLocation)
+    const fileName = basename(nativeLocation);
     // we copy the file to the cache directory (.nx/cache by default) and prefix with nxVersion to avoid stale files being loaded
     const tmpFile = join(cacheDir, nxVersion + '-' + fileName);
     if (existsSync(tmpFile)) {
@@ -72,6 +72,5 @@ const indexModulePath = require.resolve('./native-bindings.js');
 delete require.cache[indexModulePath];
 const indexModule = require('./native-bindings.js');
 
-
 module.exports = indexModule;
 Module._load = originalLoad;

package/src/native/native-bindings.js

@@ -1,27 +1,24 @@
-const { existsSync, readFileSync } = require('fs');
-const { join } = require('path');
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
 
-const { platform, arch } = process;
+const { platform, arch } = process
 
-let nativeBinding = null;
-let localFileExisted = false;
-let loadError = null;
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
 
 function isMusl() {
   // For Node 10
   if (!process.report || typeof process.report.getReport !== 'function') {
     try {
-      const lddPath = require('child_process')
-        .execSync('which ldd')
-        .toString()
-        .trim();
-      return readFileSync(lddPath, 'utf8').includes('musl');
+      const lddPath = require('child_process').execSync('which ldd').toString().trim();
+      return readFileSync(lddPath, 'utf8').includes('musl')
     } catch (e) {
-      return true;
+      return true
     }
   } else {
-    const { glibcVersionRuntime } = process.report.getReport().header;
-    return !glibcVersionRuntime;
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
   }
 }
 
@@ -29,262 +26,243 @@ switch (platform) {
   case 'android':
     switch (arch) {
       case 'arm64':
-        localFileExisted = existsSync(join(__dirname, 'nx.android-arm64.node'));
+        localFileExisted = existsSync(join(__dirname, 'nx.android-arm64.node'))
         try {
           if (localFileExisted) {
-            nativeBinding = require('./nx.android-arm64.node');
+            nativeBinding = require('./nx.android-arm64.node')
           } else {
-            nativeBinding = require('@nx/nx-android-arm64');
+            nativeBinding = require('@nx/nx-android-arm64')
           }
         } catch (e) {
-          loadError = e;
+          loadError = e
         }
-        break;
+        break
       case 'arm':
-        localFileExisted = existsSync(
-          join(__dirname, 'nx.android-arm-eabi.node')
-        );
+        localFileExisted = existsSync(join(__dirname, 'nx.android-arm-eabi.node'))
         try {
           if (localFileExisted) {
-            nativeBinding = require('./nx.android-arm-eabi.node');
+            nativeBinding = require('./nx.android-arm-eabi.node')
           } else {
-            nativeBinding = require('@nx/nx-android-arm-eabi');
+            nativeBinding = require('@nx/nx-android-arm-eabi')
           }
         } catch (e) {
-          loadError = e;
+          loadError = e
         }
-        break;
+        break
       default:
-        throw new Error(`Unsupported architecture on Android ${arch}`);
+        throw new Error(`Unsupported architecture on Android ${arch}`)
     }
-    break;
+    break
   case 'win32':
     switch (arch) {
       case 'x64':
         localFileExisted = existsSync(
           join(__dirname, 'nx.win32-x64-msvc.node')
-        );
+        )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./nx.win32-x64-msvc.node');
+            nativeBinding = require('./nx.win32-x64-msvc.node')
           } else {
-            nativeBinding = require('@nx/nx-win32-x64-msvc');
+            nativeBinding = require('@nx/nx-win32-x64-msvc')
           }
         } catch (e) {
-          loadError = e;
+          loadError = e
         }
-        break;
+        break
       case 'ia32':
         localFileExisted = existsSync(
           join(__dirname, 'nx.win32-ia32-msvc.node')
-        );
+        )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./nx.win32-ia32-msvc.node');
+            nativeBinding = require('./nx.win32-ia32-msvc.node')
           } else {
-            nativeBinding = require('@nx/nx-win32-ia32-msvc');
+            nativeBinding = require('@nx/nx-win32-ia32-msvc')
           }
         } catch (e) {
-          loadError = e;
+          loadError = e
         }
-        break;
+        break
       case 'arm64':
         localFileExisted = existsSync(
           join(__dirname, 'nx.win32-arm64-msvc.node')
-        );
+        )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./nx.win32-arm64-msvc.node');
+            nativeBinding = require('./nx.win32-arm64-msvc.node')
           } else {
-            nativeBinding = require('@nx/nx-win32-arm64-msvc');
+            nativeBinding = require('@nx/nx-win32-arm64-msvc')
           }
         } catch (e) {
-          loadError = e;
+          loadError = e
         }
-        break;
+        break
       default:
-        throw new Error(`Unsupported architecture on Windows: ${arch}`);
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
     }
-    break;
+    break
   case 'darwin':
-    localFileExisted = existsSync(join(__dirname, 'nx.darwin-universal.node'));
+    localFileExisted = existsSync(join(__dirname, 'nx.darwin-universal.node'))
     try {
       if (localFileExisted) {
-        nativeBinding = require('./nx.darwin-universal.node');
+        nativeBinding = require('./nx.darwin-universal.node')
       } else {
-        nativeBinding = require('@nx/nx-darwin-universal');
+        nativeBinding = require('@nx/nx-darwin-universal')
       }
-      break;
+      break
     } catch {}
     switch (arch) {
       case 'x64':
-        localFileExisted = existsSync(join(__dirname, 'nx.darwin-x64.node'));
+        localFileExisted = existsSync(join(__dirname, 'nx.darwin-x64.node'))
         try {
           if (localFileExisted) {
-            nativeBinding = require('./nx.darwin-x64.node');
+            nativeBinding = require('./nx.darwin-x64.node')
           } else {
-            nativeBinding = require('@nx/nx-darwin-x64');
+            nativeBinding = require('@nx/nx-darwin-x64')
           }
         } catch (e) {
-          loadError = e;
+          loadError = e
         }
-        break;
+        break
       case 'arm64':
-        localFileExisted = existsSync(join(__dirname, 'nx.darwin-arm64.node'));
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.darwin-arm64.node')
+        )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./nx.darwin-arm64.node');
+            nativeBinding = require('./nx.darwin-arm64.node')
           } else {
-            nativeBinding = require('@nx/nx-darwin-arm64');
+            nativeBinding = require('@nx/nx-darwin-arm64')
           }
         } catch (e) {
-          loadError = e;
+          loadError = e
         }
-        break;
+        break
       default:
-        throw new Error(`Unsupported architecture on macOS: ${arch}`);
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
     }
-    break;
+    break
   case 'freebsd':
     if (arch !== 'x64') {
-      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`);
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
     }
-    localFileExisted = existsSync(join(__dirname, 'nx.freebsd-x64.node'));
+    localFileExisted = existsSync(join(__dirname, 'nx.freebsd-x64.node'))
     try {
       if (localFileExisted) {
-        nativeBinding = require('./nx.freebsd-x64.node');
+        nativeBinding = require('./nx.freebsd-x64.node')
       } else {
-        nativeBinding = require('@nx/nx-freebsd-x64');
+        nativeBinding = require('@nx/nx-freebsd-x64')
       }
     } catch (e) {
-      loadError = e;
+      loadError = e
     }
-    break;
+    break
   case 'linux':
     switch (arch) {
       case 'x64':
         if (isMusl()) {
           localFileExisted = existsSync(
             join(__dirname, 'nx.linux-x64-musl.node')
-          );
+          )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./nx.linux-x64-musl.node');
+              nativeBinding = require('./nx.linux-x64-musl.node')
             } else {
-              nativeBinding = require('@nx/nx-linux-x64-musl');
+              nativeBinding = require('@nx/nx-linux-x64-musl')
             }
           } catch (e) {
-            loadError = e;
+            loadError = e
           }
         } else {
           localFileExisted = existsSync(
             join(__dirname, 'nx.linux-x64-gnu.node')
-          );
+          )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./nx.linux-x64-gnu.node');
+              nativeBinding = require('./nx.linux-x64-gnu.node')
             } else {
-              nativeBinding = require('@nx/nx-linux-x64-gnu');
+              nativeBinding = require('@nx/nx-linux-x64-gnu')
             }
           } catch (e) {
-            loadError = e;
+            loadError = e
           }
         }
-        break;
+        break
       case 'arm64':
         if (isMusl()) {
           localFileExisted = existsSync(
             join(__dirname, 'nx.linux-arm64-musl.node')
-          );
+          )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./nx.linux-arm64-musl.node');
+              nativeBinding = require('./nx.linux-arm64-musl.node')
             } else {
-              nativeBinding = require('@nx/nx-linux-arm64-musl');
+              nativeBinding = require('@nx/nx-linux-arm64-musl')
             }
           } catch (e) {
-            loadError = e;
+            loadError = e
           }
         } else {
           localFileExisted = existsSync(
             join(__dirname, 'nx.linux-arm64-gnu.node')
-          );
+          )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./nx.linux-arm64-gnu.node');
+              nativeBinding = require('./nx.linux-arm64-gnu.node')
             } else {
-              nativeBinding = require('@nx/nx-linux-arm64-gnu');
+              nativeBinding = require('@nx/nx-linux-arm64-gnu')
             }
           } catch (e) {
-            loadError = e;
+            loadError = e
           }
         }
-        break;
+        break
       case 'arm':
         localFileExisted = existsSync(
           join(__dirname, 'nx.linux-arm-gnueabihf.node')
-        );
+        )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./nx.linux-arm-gnueabihf.node');
+            nativeBinding = require('./nx.linux-arm-gnueabihf.node')
           } else {
-            nativeBinding = require('@nx/nx-linux-arm-gnueabihf');
+            nativeBinding = require('@nx/nx-linux-arm-gnueabihf')
           }
         } catch (e) {
-          loadError = e;
+          loadError = e
         }
-        break;
+        break
       default:
-        throw new Error(`Unsupported architecture on Linux: ${arch}`);
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
     }
-    break;
+    break
   default:
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
 }
 
 if (!nativeBinding) {
   if (loadError) {
-    throw loadError;
+    throw loadError
   }
-  throw new Error(`Failed to load native binding`);
+  throw new Error(`Failed to load native binding`)
 }
 
-const {
-  expandOutputs,
-  getFilesForOutputs,
-  remove,
-  copy,
-  hashArray,
-  hashFile,
-  ImportResult,
-  findImports,
-  transferProjectGraph,
-  ChildProcess,
-  RustPseudoTerminal,
-  HashPlanner,
-  TaskHasher,
-  EventType,
-  Watcher,
-  WorkspaceContext,
-  WorkspaceErrors,
-  testOnlyTransferFileMap,
-} = nativeBinding;
+const { expandOutputs, getFilesForOutputs, remove, copy, hashArray, hashFile, ImportResult, findImports, transferProjectGraph, ChildProcess, RustPseudoTerminal, HashPlanner, TaskHasher, EventType, Watcher, WorkspaceContext, WorkspaceErrors, testOnlyTransferFileMap } = nativeBinding
 
-module.exports.expandOutputs = expandOutputs;
-module.exports.getFilesForOutputs = getFilesForOutputs;
-module.exports.remove = remove;
-module.exports.copy = copy;
-module.exports.hashArray = hashArray;
-module.exports.hashFile = hashFile;
-module.exports.ImportResult = ImportResult;
-module.exports.findImports = findImports;
-module.exports.transferProjectGraph = transferProjectGraph;
-module.exports.ChildProcess = ChildProcess;
-module.exports.RustPseudoTerminal = RustPseudoTerminal;
-module.exports.HashPlanner = HashPlanner;
-module.exports.TaskHasher = TaskHasher;
-module.exports.EventType = EventType;
-module.exports.Watcher = Watcher;
-module.exports.WorkspaceContext = WorkspaceContext;
-module.exports.WorkspaceErrors = WorkspaceErrors;
-module.exports.testOnlyTransferFileMap = testOnlyTransferFileMap;
+module.exports.expandOutputs = expandOutputs
+module.exports.getFilesForOutputs = getFilesForOutputs
+module.exports.remove = remove
+module.exports.copy = copy
+module.exports.hashArray = hashArray
+module.exports.hashFile = hashFile
+module.exports.ImportResult = ImportResult
+module.exports.findImports = findImports
+module.exports.transferProjectGraph = transferProjectGraph
+module.exports.ChildProcess = ChildProcess
+module.exports.RustPseudoTerminal = RustPseudoTerminal
+module.exports.HashPlanner = HashPlanner
+module.exports.TaskHasher = TaskHasher
+module.exports.EventType = EventType
+module.exports.Watcher = Watcher
+module.exports.WorkspaceContext = WorkspaceContext
+module.exports.WorkspaceErrors = WorkspaceErrors
+module.exports.testOnlyTransferFileMap = testOnlyTransferFileMap

package/src/native/transform-objects.js

@@ -31,6 +31,7 @@ function transformProjectGraphForRust(graph) {
     }
     for (const [projectName, externalNode] of Object.entries(graph.externalNodes ?? {})) {
         externalNodes[projectName] = {
+            packageName: externalNode.data.packageName,
             hash: externalNode.data.hash,
             version: externalNode.data.version,
         };

package/src/project-graph/error-types.d.ts

@@ -19,7 +19,7 @@ export declare class ProjectGraphError extends Error {
      */
     getPartialProjectGraph(): ProjectGraph;
     getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | ProcessDependenciesError | ProcessProjectGraphError)[];
+    getErrors(): (ProcessDependenciesError | ProcessProjectGraphError | CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError)[];
 }
 export declare class ProjectsWithConflictingNamesError extends Error {
     projects: Record<string, ProjectConfiguration>;
@@ -69,3 +69,7 @@ export declare class DaemonProjectGraphError extends Error {
     readonly sourceMaps: ConfigurationSourceMaps;
     constructor(errors: any[], projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps);
 }
+export declare class LoadPluginError extends Error {
+    plugin: string;
+    constructor(plugin: string, cause: Error);
+}

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

@@ -1,7 +1,7 @@
 "use strict";
 var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DaemonProjectGraphError = exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.isProjectsWithNoNameError = exports.ProjectsWithNoNameError = exports.isProjectsWithConflictingNamesError = exports.ProjectsWithConflictingNamesError = exports.ProjectGraphError = void 0;
+exports.LoadPluginError = exports.DaemonProjectGraphError = exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.isProjectsWithNoNameError = exports.ProjectsWithNoNameError = exports.isProjectsWithConflictingNamesError = exports.ProjectsWithConflictingNamesError = exports.ProjectGraphError = void 0;
 const tslib_1 = require("tslib");
 class ProjectGraphError extends Error {
     constructor(errors, partialProjectGraph, partialSourceMaps) {
@@ -145,3 +145,13 @@ class DaemonProjectGraphError extends Error {
     }
 }
 exports.DaemonProjectGraphError = DaemonProjectGraphError;
+class LoadPluginError extends Error {
+    constructor(plugin, cause) {
+        super(`Could not load plugin ${plugin}`, {
+            cause,
+        });
+        this.plugin = plugin;
+        this.name = this.constructor.name;
+    }
+}
+exports.LoadPluginError = LoadPluginError;

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -1,7 +1,9 @@
+/// <reference types="node" />
 import { ProjectGraph, ProjectGraphProcessorContext } from '../../../config/project-graph';
 import { PluginConfiguration } from '../../../config/nx-json';
 import { CreateDependenciesContext, CreateNodesContext } from '../public-api';
 import { LoadedNxPlugin } from '../internal-api';
+import { Serializable } from 'child_process';
 export interface PluginWorkerLoadMessage {
     type: 'load';
     payload: {
@@ -19,7 +21,7 @@ export interface PluginWorkerLoadResult {
         success: true;
     } | {
         success: false;
-        error: string;
+        error: Error;
     };
 }
 export interface PluginWorkerCreateNodesMessage {
@@ -38,7 +40,7 @@ export interface PluginWorkerCreateNodesResult {
         tx: string;
     } | {
         success: false;
-        error: string;
+        error: Error;
         tx: string;
     };
 }
@@ -57,7 +59,7 @@ export interface PluginCreateDependenciesResult {
         tx: string;
     } | {
         success: false;
-        error: string;
+        error: Error;
         tx: string;
     };
 }
@@ -77,18 +79,19 @@ export interface PluginWorkerProcessProjectGraphResult {
         tx: string;
     } | {
         success: false;
-        error: string;
+        error: Error;
         tx: string;
     };
 }
 export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage;
 export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult;
+export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
+export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;
 type MaybePromise<T> = T | Promise<T>;
 type MessageHandlerReturn<T extends PluginWorkerMessage | PluginWorkerResult> = T extends PluginWorkerResult ? MaybePromise<PluginWorkerMessage | void> : MaybePromise<PluginWorkerResult | void>;
-export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(raw: string | T, handlers: {
+export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(raw: T, handlers: {
     [K in T['type']]: (payload: Extract<T, {
         type: K;
     }>['payload']) => MessageHandlerReturn<T>;
 }): Promise<void>;
-export declare function createMessage(message: PluginWorkerMessage | PluginWorkerResult): string;
 export {};