nx 18.3.1 → 18.4.0-canary.20240418-e549ea2

package/.eslintrc.json

@@ -25,6 +25,10 @@
               {
                 "group": ["nx/*"],
                 "message": "Circular import in 'nx' found. Use relative path."
+              },
+              {
+                "group": ["**/native-bindings", "**/native-bindings.js"],
+                "message": "Direct imports from native-bindings.js are not allowed. Import from index.js instead."
               }
             ]
           }

package/bin/nx.js

@@ -3,8 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const find_workspace_root_1 = require("../src/utils/find-workspace-root");
 const chalk = require("chalk");
-const dotenv_1 = require("dotenv");
-const dotenv_expand_1 = require("dotenv-expand");
+const dotenv_1 = require("../src/utils/dotenv");
 const init_local_1 = require("./init-local");
 const output_1 = require("../src/utils/output");
 const installation_directory_1 = require("../src/utils/installation-directory");
@@ -20,15 +19,18 @@ const client_1 = require("../src/daemon/client/client");
 function main() {
     if (process.argv[2] !== 'report' &&
         process.argv[2] !== '--version' &&
-        process.argv[2] !== '--help') {
+        process.argv[2] !== '--help' &&
+        process.argv[2] !== 'reset') {
         (0, assert_supported_platform_1.assertSupportedPlatform)();
     }
     require('nx/src/utils/perf-logging');
+    const workspace = (0, find_workspace_root_1.findWorkspaceRoot)(process.cwd());
     perf_hooks_1.performance.mark('loading dotenv files:start');
-    loadDotEnvFiles();
+    if (workspace) {
+        (0, dotenv_1.loadRootEnvFiles)(workspace.dir);
+    }
     perf_hooks_1.performance.mark('loading dotenv files:end');
     perf_hooks_1.performance.measure('loading dotenv files', 'loading dotenv files:start', 'loading dotenv files:end');
-    const workspace = (0, find_workspace_root_1.findWorkspaceRoot)(process.cwd());
     // new is a special case because there is no local workspace to load
     if (process.argv[2] === 'new' ||
         process.argv[2] === '_migrate' ||
@@ -81,20 +83,6 @@ function main() {
         }
     }
 }
-/**
- * This loads dotenv files from:
- * - .env
- * - .local.env
- * - .env.local
- */
-function loadDotEnvFiles() {
-    for (const file of ['.local.env', '.env.local', '.env']) {
-        const myEnv = (0, dotenv_1.config)({
-            path: file,
-        });
-        (0, dotenv_expand_1.expand)(myEnv);
-    }
-}
 function handleNoWorkspace(globalNxVersion) {
     output_1.output.log({
         title: `The current directory isn't part of an Nx workspace.`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "18.3.1",
+  "version": "18.4.0-canary.20240418-e549ea2",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -66,7 +66,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "18.3.1"
+    "@nrwl/tao": "18.4.0-canary.20240418-e549ea2"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "18.3.1",
-    "@nx/nx-darwin-arm64": "18.3.1",
-    "@nx/nx-linux-x64-gnu": "18.3.1",
-    "@nx/nx-linux-x64-musl": "18.3.1",
-    "@nx/nx-win32-x64-msvc": "18.3.1",
-    "@nx/nx-linux-arm64-gnu": "18.3.1",
-    "@nx/nx-linux-arm64-musl": "18.3.1",
-    "@nx/nx-linux-arm-gnueabihf": "18.3.1",
-    "@nx/nx-win32-arm64-msvc": "18.3.1",
-    "@nx/nx-freebsd-x64": "18.3.1"
+    "@nx/nx-darwin-x64": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-darwin-arm64": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-linux-x64-gnu": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-linux-x64-musl": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-win32-x64-msvc": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-linux-arm64-gnu": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-linux-arm64-musl": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-linux-arm-gnueabihf": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-win32-arm64-msvc": "18.4.0-canary.20240418-e549ea2",
+    "@nx/nx-freebsd-x64": "18.4.0-canary.20240418-e549ea2"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/init/implementation/react/check-for-uncommitted-changes.js

@@ -3,12 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkForUncommittedChanges = void 0;
 const child_process_1 = require("child_process");
 function checkForUncommittedChanges() {
-    const gitResult = (0, child_process_1.execSync)(`git status --porcelain`);
-    if (gitResult.length > 0) {
+    const gitResult = (0, child_process_1.execSync)('git status --porcelain').toString();
+    const filteredResults = gitResult
+        .split('\n')
+        .filter((line) => !line.includes('.nx') && line.trim().length > 0);
+    if (filteredResults.length > 0) {
         console.log('❗️ Careful!');
         console.log('You have uncommitted changes in your repository.');
         console.log('');
-        console.log(gitResult.toString());
+        console.log(filteredResults.join('\n').toString());
         console.log('Please commit your changes before running the migrator!');
         process.exit(1);
     }

package/src/daemon/cache.js

@@ -30,6 +30,24 @@ async function safelyCleanUpExistingProcess() {
     if (daemonProcessJson && daemonProcessJson.processId) {
         try {
             process.kill(daemonProcessJson.processId);
+            // we wait for the process to actually shut down before returning
+            await new Promise((resolve, reject) => {
+                let count = 0;
+                const interval = setInterval(() => {
+                    try {
+                        // sending a signal 0 to a process checks if the process is running instead of actually killing it
+                        process.kill(daemonProcessJson.processId, 0);
+                    }
+                    catch (e) {
+                        clearInterval(interval);
+                        resolve();
+                    }
+                    if ((count += 1) > 200) {
+                        clearInterval(interval);
+                        reject(`Daemon process ${daemonProcessJson.processId} didn't exit after 2 seconds.`);
+                    }
+                }, 10);
+            });
         }
         catch { }
     }

package/src/daemon/client/client.js

@@ -18,8 +18,7 @@ const promised_based_queue_1 = require("../../utils/promised-based-queue");
 const nx_json_1 = require("../../config/nx-json");
 const daemon_socket_messenger_1 = require("./daemon-socket-messenger");
 const cache_1 = require("../cache");
-const daemon_project_graph_error_1 = require("../daemon-project-graph-error");
-const project_graph_1 = require("../../project-graph/project-graph");
+const error_types_1 = require("../../project-graph/error-types");
 const DAEMON_ENV_SETTINGS = {
     NX_PROJECT_GLOB_CACHE: 'false',
     NX_CACHE_PROJECTS_CONFIG: 'false',
@@ -101,8 +100,8 @@ class DaemonClient {
             };
         }
         catch (e) {
-            if (e.name === daemon_project_graph_error_1.DaemonProjectGraphError.name) {
-                throw project_graph_1.ProjectGraphError.fromDaemonProjectGraphError(e);
+            if (e.name === error_types_1.DaemonProjectGraphError.name) {
+                throw error_types_1.ProjectGraphError.fromDaemonProjectGraphError(e);
             }
             else {
                 throw e;

package/src/daemon/server/handle-hash-tasks.js

@@ -4,7 +4,7 @@ exports.handleHashTasks = void 0;
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
 const task_hasher_1 = require("../../hasher/task-hasher");
 const configuration_1 = require("../../config/configuration");
-const daemon_project_graph_error_1 = require("../daemon-project-graph-error");
+const error_types_1 = require("../../project-graph/error-types");
 /**
  * We use this not to recreated hasher for every hash operation
  * TaskHasher has a cache inside, so keeping it around results in faster performance
@@ -15,7 +15,7 @@ async function handleHashTasks(payload) {
     const { error, projectGraph: _graph, allWorkspaceFiles, fileMap, rustReferences, } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
     let projectGraph = _graph;
     if (error) {
-        if (error instanceof daemon_project_graph_error_1.DaemonProjectGraphError) {
+        if (error instanceof error_types_1.DaemonProjectGraphError) {
             projectGraph = error.projectGraph;
         }
         else {

package/src/daemon/server/project-graph-incremental-recomputation.js

@@ -13,7 +13,6 @@ const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
 const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
 const logger_1 = require("./logger");
-const daemon_project_graph_error_1 = require("../daemon-project-graph-error");
 const plugins_1 = require("./plugins");
 const error_types_1 = require("../../project-graph/error-types");
 let cachedSerializedProjectGraphPromise;
@@ -180,7 +179,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
         }
         if (errors.length > 0) {
             return {
-                error: new daemon_project_graph_error_1.DaemonProjectGraphError(errors, g.projectGraph, graphNodes.sourceMaps),
+                error: new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, graphNodes.sourceMaps),
                 projectGraph: null,
                 projectFileMapCache: null,
                 fileMap: null,

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 daemon_project_graph_error_1 = require("./daemon-project-graph-error");
+const error_types_1 = require("../project-graph/error-types");
 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.
@@ -33,7 +33,7 @@ function serializeError(error) {
     if (!error) {
         return null;
     }
-    if (error instanceof daemon_project_graph_error_1.DaemonProjectGraphError) {
+    if (error instanceof error_types_1.DaemonProjectGraphError) {
         error.errors = error.errors.map((e) => JSON.parse(serializeError(e)));
     }
     return `{${Object.getOwnPropertyNames(error)

package/src/native/index.js

@@ -1,268 +1,77 @@
-const { existsSync, readFileSync } = require('fs')
-const { join } = 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 { platform, arch } = process
+const nxPackages = new Set([
+  '@nx/nx-android-arm64',
+  '@nx/nx-android-arm-eabi',
+  '@nx/nx-win32-x64-msvc',
+  '@nx/nx-win32-ia32-msvc',
+  '@nx/nx-win32-arm64-msvc',
+  '@nx/nx-darwin-universal',
+  '@nx/nx-darwin-x64',
+  '@nx/nx-darwin-arm64',
+  '@nx/nx-freebsd-x64',
+  '@nx/nx-linux-x64-musl',
+  '@nx/nx-linux-x64-gnu',
+  '@nx/nx-linux-arm64-musl',
+  '@nx/nx-linux-arm64-gnu',
+  '@nx/nx-linux-arm-gnueabihf',
+]);
 
-let nativeBinding = null
-let localFileExisted = false
-let loadError = null
+const localNodeFiles = [
+  'nx.android-arm64.node',
+  'nx.android-arm-eabi.node',
+  'nx.win32-x64-msvc.node',
+  'nx.win32-ia32-msvc.node',
+  'nx.win32-arm64-msvc.node',
+  'nx.darwin-universal.node',
+  'nx.darwin-x64.node',
+  'nx.darwin-arm64.node',
+  'nx.freebsd-x64.node',
+  'nx.linux-x64-musl.node',
+  'nx.linux-x64-gnu.node',
+  'nx.linux-arm64-musl.node',
+  'nx.linux-arm64-gnu.node',
+  'nx.linux-arm-gnueabihf.node',
+];
 
-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')
-    } catch (e) {
-      return true
-    }
-  } else {
-    const { glibcVersionRuntime } = process.report.getReport().header
-    return !glibcVersionRuntime
-  }
-}
+const originalLoad = Module._load;
 
-switch (platform) {
-  case 'android':
-    switch (arch) {
-      case 'arm64':
-        localFileExisted = existsSync(join(__dirname, 'nx.android-arm64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nx.android-arm64.node')
-          } else {
-            nativeBinding = require('@nx/nx-android-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm':
-        localFileExisted = existsSync(join(__dirname, 'nx.android-arm-eabi.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nx.android-arm-eabi.node')
-          } else {
-            nativeBinding = require('@nx/nx-android-arm-eabi')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Android ${arch}`)
-    }
-    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')
-          } else {
-            nativeBinding = require('@nx/nx-win32-x64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'ia32':
-        localFileExisted = existsSync(
-          join(__dirname, 'nx.win32-ia32-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nx.win32-ia32-msvc.node')
-          } else {
-            nativeBinding = require('@nx/nx-win32-ia32-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'nx.win32-arm64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nx.win32-arm64-msvc.node')
-          } else {
-            nativeBinding = require('@nx/nx-win32-arm64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Windows: ${arch}`)
-    }
-    break
-  case 'darwin':
-    localFileExisted = existsSync(join(__dirname, 'nx.darwin-universal.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./nx.darwin-universal.node')
-      } else {
-        nativeBinding = require('@nx/nx-darwin-universal')
-      }
-      break
-    } catch {}
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(join(__dirname, 'nx.darwin-x64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nx.darwin-x64.node')
-          } else {
-            nativeBinding = require('@nx/nx-darwin-x64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'nx.darwin-arm64.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nx.darwin-arm64.node')
-          } else {
-            nativeBinding = require('@nx/nx-darwin-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+// 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.
+Module._load = function (request, parent, isMain) {
+  const modulePath = request;
+  if (
+    nxPackages.has(modulePath) ||
+    localNodeFiles.some((f) => modulePath.endsWith(f))
+  ) {
+    const nativeLocation = require.resolve(modulePath);
+    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)) {
+      return originalLoad.apply(this, [tmpFile, parent, isMain]);
     }
-    break
-  case 'freebsd':
-    if (arch !== 'x64') {
-      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    if (!existsSync(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
     }
-    localFileExisted = existsSync(join(__dirname, 'nx.freebsd-x64.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./nx.freebsd-x64.node')
-      } else {
-        nativeBinding = require('@nx/nx-freebsd-x64')
-      }
-    } catch (e) {
-      loadError = e
-    }
-    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')
-            } else {
-              nativeBinding = require('@nx/nx-linux-x64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'nx.linux-x64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nx.linux-x64-gnu.node')
-            } else {
-              nativeBinding = require('@nx/nx-linux-x64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'nx.linux-arm64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nx.linux-arm64-musl.node')
-            } else {
-              nativeBinding = require('@nx/nx-linux-arm64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'nx.linux-arm64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nx.linux-arm64-gnu.node')
-            } else {
-              nativeBinding = require('@nx/nx-linux-arm64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm':
-        localFileExisted = existsSync(
-          join(__dirname, 'nx.linux-arm-gnueabihf.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nx.linux-arm-gnueabihf.node')
-          } else {
-            nativeBinding = require('@nx/nx-linux-arm-gnueabihf')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Linux: ${arch}`)
-    }
-    break
-  default:
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
-}
-
-if (!nativeBinding) {
-  if (loadError) {
-    throw loadError
+    copyFileSync(nativeLocation, tmpFile);
+    return originalLoad.apply(this, [tmpFile, parent, isMain]);
+  } else {
+    // call the original _load function for everything else
+    return originalLoad.apply(this, arguments);
   }
-  throw new Error(`Failed to load native binding`)
-}
+};
+
+const indexModulePath = require.resolve('./native-bindings.js');
+delete require.cache[indexModulePath];
+const indexModule = require('./native-bindings.js');
 
-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 = indexModule;
+Module._load = originalLoad;

package/src/native/native-bindings.js

@@ -0,0 +1,290 @@
+const { existsSync, readFileSync } = require('fs');
+const { join } = require('path');
+
+const { platform, arch } = process;
+
+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');
+    } catch (e) {
+      return true;
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header;
+    return !glibcVersionRuntime;
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'nx.android-arm64.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.android-arm64.node');
+          } else {
+            nativeBinding = require('@nx/nx-android-arm64');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'arm':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.android-arm-eabi.node')
+        );
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.android-arm-eabi.node');
+          } else {
+            nativeBinding = require('@nx/nx-android-arm-eabi');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`);
+    }
+    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');
+          } else {
+            nativeBinding = require('@nx/nx-win32-x64-msvc');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.win32-ia32-msvc.node')
+        );
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.win32-ia32-msvc.node');
+          } else {
+            nativeBinding = require('@nx/nx-win32-ia32-msvc');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.win32-arm64-msvc.node')
+        );
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.win32-arm64-msvc.node');
+          } else {
+            nativeBinding = require('@nx/nx-win32-arm64-msvc');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`);
+    }
+    break;
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'nx.darwin-universal.node'));
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./nx.darwin-universal.node');
+      } else {
+        nativeBinding = require('@nx/nx-darwin-universal');
+      }
+      break;
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'nx.darwin-x64.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.darwin-x64.node');
+          } else {
+            nativeBinding = require('@nx/nx-darwin-x64');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'nx.darwin-arm64.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.darwin-arm64.node');
+          } else {
+            nativeBinding = require('@nx/nx-darwin-arm64');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`);
+    }
+    break;
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`);
+    }
+    localFileExisted = existsSync(join(__dirname, 'nx.freebsd-x64.node'));
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./nx.freebsd-x64.node');
+      } else {
+        nativeBinding = require('@nx/nx-freebsd-x64');
+      }
+    } catch (e) {
+      loadError = e;
+    }
+    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');
+            } else {
+              nativeBinding = require('@nx/nx-linux-x64-musl');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nx.linux-x64-gnu.node')
+          );
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nx.linux-x64-gnu.node');
+            } else {
+              nativeBinding = require('@nx/nx-linux-x64-gnu');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        }
+        break;
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nx.linux-arm64-musl.node')
+          );
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nx.linux-arm64-musl.node');
+            } else {
+              nativeBinding = require('@nx/nx-linux-arm64-musl');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nx.linux-arm64-gnu.node')
+          );
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nx.linux-arm64-gnu.node');
+            } else {
+              nativeBinding = require('@nx/nx-linux-arm64-gnu');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        }
+        break;
+      case 'arm':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.linux-arm-gnueabihf.node')
+        );
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.linux-arm-gnueabihf.node');
+          } else {
+            nativeBinding = require('@nx/nx-linux-arm-gnueabihf');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`);
+    }
+    break;
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError;
+  }
+  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;
+
+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/project-graph/error-types.d.ts

@@ -1,6 +1,26 @@
 import { CreateNodesResultWithContext } from './plugins/internal-api';
-import { ConfigurationResult } from './utils/project-configuration-utils';
+import { ConfigurationResult, ConfigurationSourceMaps } from './utils/project-configuration-utils';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { ProcessDependenciesError, ProcessProjectGraphError } from './build-project-graph';
+import { ProjectGraph } from '../config/project-graph';
+export declare class ProjectGraphError extends Error {
+    #private;
+    constructor(errors: Array<CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | ProcessDependenciesError | ProcessProjectGraphError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
+    /**
+     * The daemon cannot throw errors which contain methods as they are not serializable.
+     *
+     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
+     */
+    static fromDaemonProjectGraphError(e: DaemonProjectGraphError): ProjectGraphError;
+    /**
+     * This gets the partial project graph despite the errors which occured.
+     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
+     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
+     */
+    getPartialProjectGraph(): ProjectGraph;
+    getPartialSourcemaps(): ConfigurationSourceMaps;
+    getErrors(): (CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | ProcessDependenciesError | ProcessProjectGraphError)[];
+}
 export declare class ProjectsWithConflictingNamesError extends Error {
     projects: Record<string, ProjectConfiguration>;
     constructor(conflicts: Map<string, string[]>, projects: Record<string, ProjectConfiguration>);
@@ -43,3 +63,9 @@ export declare class MergeNodesError extends Error {
 export declare function isCreateNodesError(e: unknown): e is CreateNodesError;
 export declare function isAggregateCreateNodesError(e: unknown): e is AggregateCreateNodesError;
 export declare function isMergeNodesError(e: unknown): e is MergeNodesError;
+export declare class DaemonProjectGraphError extends Error {
+    errors: any[];
+    readonly projectGraph: ProjectGraph;
+    readonly sourceMaps: ConfigurationSourceMaps;
+    constructor(errors: any[], projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps);
+}

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

@@ -1,6 +1,47 @@
 "use strict";
+var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.isProjectsWithNoNameError = exports.ProjectsWithNoNameError = exports.isProjectsWithConflictingNamesError = exports.ProjectsWithConflictingNamesError = void 0;
+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) {
+        super(`Failed to process project graph.`);
+        _ProjectGraphError_errors.set(this, void 0);
+        _ProjectGraphError_partialProjectGraph.set(this, void 0);
+        _ProjectGraphError_partialSourceMaps.set(this, void 0);
+        this.name = this.constructor.name;
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_errors, errors, "f");
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialProjectGraph, partialProjectGraph, "f");
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialSourceMaps, partialSourceMaps, "f");
+        this.stack = `${this.message}\n  ${errors
+            .map((error) => error.stack.split('\n').join('\n  '))
+            .join('\n')}`;
+    }
+    /**
+     * The daemon cannot throw errors which contain methods as they are not serializable.
+     *
+     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
+     */
+    static fromDaemonProjectGraphError(e) {
+        return new ProjectGraphError(e.errors, e.projectGraph, e.sourceMaps);
+    }
+    /**
+     * This gets the partial project graph despite the errors which occured.
+     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
+     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
+     */
+    getPartialProjectGraph() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialProjectGraph, "f");
+    }
+    getPartialSourcemaps() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialSourceMaps, "f");
+    }
+    getErrors() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_errors, "f");
+    }
+}
+exports.ProjectGraphError = ProjectGraphError;
+_ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
 class ProjectsWithConflictingNamesError extends Error {
     constructor(conflicts, projects) {
         super([
@@ -94,3 +135,13 @@ function isMergeNodesError(e) {
         (typeof e === 'object' && 'name' in e && e?.name === MergeNodesError.name));
 }
 exports.isMergeNodesError = isMergeNodesError;
+class DaemonProjectGraphError extends Error {
+    constructor(errors, projectGraph, sourceMaps) {
+        super(`The Daemon Process threw an error while calculating the project graph. Convert this error to a ProjectGraphError to get more information.`);
+        this.errors = errors;
+        this.projectGraph = projectGraph;
+        this.sourceMaps = sourceMaps;
+        this.name = this.constructor.name;
+    }
+}
+exports.DaemonProjectGraphError = DaemonProjectGraphError;

package/src/project-graph/plugins/isolation/index.js

@@ -3,14 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadNxPluginInIsolation = void 0;
 const workspace_root_1 = require("../../../utils/workspace-root");
 const plugin_pool_1 = require("./plugin-pool");
+/**
+ * Used to ensure 1 plugin : 1 worker
+ */
 const remotePluginCache = new Map();
 function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
     const cacheKey = JSON.stringify(plugin);
     if (remotePluginCache.has(cacheKey)) {
-        return remotePluginCache.get(cacheKey);
+        return [remotePluginCache.get(cacheKey), () => { }];
     }
-    const [loadingPlugin, cleanup] = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
-    remotePluginCache.set(cacheKey, [loadingPlugin, cleanup]);
-    return [loadingPlugin, cleanup];
+    const loadingPlugin = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
+    remotePluginCache.set(cacheKey, loadingPlugin);
+    // We clean up plugin workers when Nx process completes.
+    return [loadingPlugin, () => { }];
 }
 exports.loadNxPluginInIsolation = loadNxPluginInIsolation;

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

@@ -1,3 +1,3 @@
 import { PluginConfiguration } from '../../../config/nx-json';
 import { LoadedNxPlugin } from '../internal-api';
-export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): [Promise<LoadedNxPlugin>, () => void];
+export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): Promise<LoadedNxPlugin>;

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

@@ -41,16 +41,10 @@ function loadRemoteNxPlugin(plugin, root) {
         shutdownPluginWorker(worker, pendingPromises);
     };
     cleanupFunctions.add(cleanupFunction);
-    return [
-        new Promise((res, rej) => {
-            worker.on('message', createWorkerHandler(worker, pendingPromises, res, rej));
-            worker.on('exit', exitHandler);
-        }),
-        () => {
-            cleanupFunction();
-            cleanupFunctions.delete(cleanupFunction);
-        },
-    ];
+    return new Promise((res, rej) => {
+        worker.on('message', createWorkerHandler(worker, pendingPromises, res, rej));
+        worker.on('exit', exitHandler);
+    });
 }
 exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
 async function shutdownPluginWorker(worker, pendingPromises) {

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

@@ -1,9 +1,5 @@
-import { ProcessDependenciesError, ProcessProjectGraphError } from './build-project-graph';
 import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
-import { ConfigurationSourceMaps } from './utils/project-configuration-utils';
-import { CreateNodesError, MergeNodesError, ProjectsWithNoNameError, ProjectsWithConflictingNamesError } from './error-types';
-import { DaemonProjectGraphError } from '../daemon/daemon-project-graph-error';
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -16,26 +12,8 @@ export declare function readCachedProjectConfiguration(projectName: string): Pro
 export declare function readProjectsConfigurationFromProjectGraph(projectGraph: ProjectGraph): ProjectsConfigurations;
 export declare function buildProjectGraphAndSourceMapsWithoutDaemon(): Promise<{
     projectGraph: ProjectGraph;
-    sourceMaps: ConfigurationSourceMaps;
+    sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
 }>;
-export declare class ProjectGraphError extends Error {
-    #private;
-    constructor(errors: Array<CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | ProcessDependenciesError | ProcessProjectGraphError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
-    /**
-     * The daemon cannot throw errors which contain methods as they are not serializable.
-     *
-     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
-     */
-    static fromDaemonProjectGraphError(e: DaemonProjectGraphError): ProjectGraphError;
-    /**
-     * This gets the partial project graph despite the errors which occured.
-     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
-     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
-     */
-    getPartialProjectGraph(): ProjectGraph;
-    getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (ProjectsWithConflictingNamesError | ProjectsWithNoNameError | MergeNodesError | CreateNodesError | ProcessDependenciesError | ProcessProjectGraphError)[];
-}
 /**
  * Computes and returns a ProjectGraph.
  *
@@ -66,5 +44,5 @@ export declare function createProjectGraphAndSourceMapsAsync(opts?: {
     resetDaemonClient?: boolean;
 }): Promise<{
     projectGraph: ProjectGraph;
-    sourceMaps: ConfigurationSourceMaps;
+    sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
 }>;

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

@@ -1,21 +1,19 @@
 "use strict";
-var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.ProjectGraphError = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
-const tslib_1 = require("tslib");
-const nx_deps_cache_1 = require("./nx-deps-cache");
-const build_project_graph_1 = require("./build-project-graph");
-const output_1 = require("../utils/output");
-const tmp_dir_1 = require("../daemon/tmp-dir");
-const strip_indents_1 = require("../utils/strip-indents");
+exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
+const tmp_dir_1 = require("../daemon/tmp-dir");
 const fileutils_1 = require("../utils/fileutils");
+const output_1 = require("../utils/output");
+const strip_indents_1 = require("../utils/strip-indents");
 const workspace_root_1 = require("../utils/workspace-root");
-const perf_hooks_1 = require("perf_hooks");
-const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
-const nx_json_1 = require("../config/nx-json");
+const build_project_graph_1 = require("./build-project-graph");
+const nx_deps_cache_1 = require("./nx-deps-cache");
 const error_types_1 = require("./error-types");
 const internal_api_1 = require("./plugins/internal-api");
+const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -122,7 +120,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         ...(createDependenciesError?.errors ?? []),
     ];
     if (errors.length > 0) {
-        throw new ProjectGraphError(errors, projectGraph, sourceMaps);
+        throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
     }
     else {
         if (cacheEnabled) {
@@ -132,49 +130,10 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     }
 }
 exports.buildProjectGraphAndSourceMapsWithoutDaemon = buildProjectGraphAndSourceMapsWithoutDaemon;
-class ProjectGraphError extends Error {
-    constructor(errors, partialProjectGraph, partialSourceMaps) {
-        super(`Failed to process project graph.`);
-        _ProjectGraphError_errors.set(this, void 0);
-        _ProjectGraphError_partialProjectGraph.set(this, void 0);
-        _ProjectGraphError_partialSourceMaps.set(this, void 0);
-        this.name = this.constructor.name;
-        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_errors, errors, "f");
-        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialProjectGraph, partialProjectGraph, "f");
-        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialSourceMaps, partialSourceMaps, "f");
-        this.stack = `${this.message}\n  ${errors
-            .map((error) => error.stack.split('\n').join('\n  '))
-            .join('\n')}`;
-    }
-    /**
-     * The daemon cannot throw errors which contain methods as they are not serializable.
-     *
-     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
-     */
-    static fromDaemonProjectGraphError(e) {
-        return new ProjectGraphError(e.errors, e.projectGraph, e.sourceMaps);
-    }
-    /**
-     * This gets the partial project graph despite the errors which occured.
-     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
-     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
-     */
-    getPartialProjectGraph() {
-        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialProjectGraph, "f");
-    }
-    getPartialSourcemaps() {
-        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialSourceMaps, "f");
-    }
-    getErrors() {
-        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_errors, "f");
-    }
-}
-exports.ProjectGraphError = ProjectGraphError;
-_ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
 function handleProjectGraphError(opts, e) {
     if (opts.exitOnError) {
         const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
-        if (e instanceof ProjectGraphError) {
+        if (e instanceof error_types_1.ProjectGraphError) {
             let title = e.message;
             if (isVerbose) {
                 title += ' See errors below.';

package/src/tasks-runner/init-tasks-runner.js

@@ -8,8 +8,10 @@ const run_command_1 = require("./run-command");
 const invoke_runner_terminal_output_life_cycle_1 = require("./life-cycles/invoke-runner-terminal-output-life-cycle");
 const perf_hooks_1 = require("perf_hooks");
 const utils_1 = require("./utils");
+const dotenv_1 = require("../utils/dotenv");
 async function initTasksRunner(nxArgs) {
     perf_hooks_1.performance.mark('init-local');
+    (0, dotenv_1.loadRootEnvFiles)();
     (0, workspace_configuration_check_1.workspaceConfigurationCheck)();
     const nxJson = (0, configuration_1.readNxJson)();
     if (nxArgs.verbose) {

package/src/utils/dotenv.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This loads dotenv files from:
+ * - .env
+ * - .local.env
+ * - .env.local
+ */
+export declare function loadRootEnvFiles(root?: string): void;

package/src/utils/dotenv.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRootEnvFiles = void 0;
+const dotenv_1 = require("dotenv");
+const dotenv_expand_1 = require("dotenv-expand");
+const workspace_root_1 = require("./workspace-root");
+const path_1 = require("path");
+/**
+ * This loads dotenv files from:
+ * - .env
+ * - .local.env
+ * - .env.local
+ */
+function loadRootEnvFiles(root = workspace_root_1.workspaceRoot) {
+    for (const file of ['.local.env', '.env.local', '.env']) {
+        const myEnv = (0, dotenv_1.config)({
+            path: (0, path_1.join)(root, file),
+        });
+        (0, dotenv_expand_1.expand)(myEnv);
+    }
+}
+exports.loadRootEnvFiles = loadRootEnvFiles;

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

@@ -1,8 +0,0 @@
-import { ProjectGraph } from '../config/project-graph';
-import { ConfigurationSourceMaps } from '../project-graph/utils/project-configuration-utils';
-export declare class DaemonProjectGraphError extends Error {
-    errors: any[];
-    readonly projectGraph: ProjectGraph;
-    readonly sourceMaps: ConfigurationSourceMaps;
-    constructor(errors: any[], projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps);
-}

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DaemonProjectGraphError = void 0;
-class DaemonProjectGraphError extends Error {
-    constructor(errors, projectGraph, sourceMaps) {
-        super(`The Daemon Process threw an error while calculating the project graph. Convert this error to a ProjectGraphError to get more information.`);
-        this.errors = errors;
-        this.projectGraph = projectGraph;
-        this.sourceMaps = sourceMaps;
-        this.name = this.constructor.name;
-    }
-}
-exports.DaemonProjectGraphError = DaemonProjectGraphError;