nx 22.7.1 → 22.7.3

package/dist/src/project-graph/plugins/resolve-plugin.js

@@ -6,28 +6,59 @@ exports.getPluginPathAndName = getPluginPathAndName;
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("node:path"));
 const node_fs_1 = require("node:fs");
+const resolve_exports_1 = require("resolve.exports");
 const packages_1 = require("../../plugins/js/utils/packages");
+const typescript_1 = require("../../plugins/js/utils/typescript");
 const fileutils_1 = require("../../utils/fileutils");
 const logger_1 = require("../../utils/logger");
 const path_1 = require("../../utils/path");
 const workspace_root_1 = require("../../utils/workspace-root");
 const find_project_for_path_1 = require("../utils/find-project-for-path");
 const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
+const TS_SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.cts', '.mts']);
 let projectsWithoutInference;
 let projectsWithoutInferencePromise = null;
 async function resolveNxPlugin(moduleName, root, paths) {
-    try {
-        require.resolve(moduleName, { paths });
-    }
-    catch {
-        // If a plugin cannot be resolved, we will need projects to resolve it
-        projectsWithoutInferencePromise ??=
-            (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
-        projectsWithoutInference ??= await projectsWithoutInferencePromise;
+    // Default plugins (see `getDefaultPlugins` in `get-plugins.ts`) are passed
+    // as absolute file paths to compiled bundles inside `nx` itself; they are
+    // never workspace-local. Skip the project load entirely for them to avoid
+    // recursing through `retrieveProjectConfigurationsWithoutPluginInference`,
+    // which itself triggers default-plugin loading.
+    if (!path.isAbsolute(moduleName)) {
+        let resolvedFromNode;
+        try {
+            resolvedFromNode = require.resolve(moduleName, { paths });
+        }
+        catch { }
+        // Load projects if Node couldn't resolve (so the local fallback can run)
+        // OR if Node resolved to a workspace-internal path (a symlinked workspace
+        // package whose source-first lookup should win over the symlinked dist).
+        if (!resolvedFromNode ||
+            isWorkspaceLocalResolution(resolvedFromNode, root)) {
+            projectsWithoutInferencePromise ??=
+                (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+            projectsWithoutInference ??= await projectsWithoutInferencePromise;
+        }
     }
     const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
     return { pluginPath, name, shouldRegisterTSTranspiler };
 }
+/**
+ * Distinguishes a symlinked workspace package (where `require.resolve`
+ * follows the package-manager symlink into the workspace source tree) from
+ * a truly-installed dependency under `node_modules/`. The former needs the
+ * source-first lookup to bypass the dist that Node would otherwise return.
+ */
+function isWorkspaceLocalResolution(resolvedPath, root) {
+    const normalizedRoot = path.normalize(root);
+    const normalizedPath = path.normalize(resolvedPath);
+    return (normalizedPath.startsWith(normalizedRoot + path.sep) &&
+        !normalizedPath.includes(path.sep + 'node_modules' + path.sep));
+}
+function isPackageResolutionError(e) {
+    const code = e.code;
+    return (code === 'MODULE_NOT_FOUND' || code === 'ERR_PACKAGE_PATH_NOT_EXPORTED');
+}
 function readPluginMainFromProjectConfiguration(plugin) {
     const { main } = Object.values(plugin.targets).find((x) => [
         '@nx/js:tsc',
@@ -46,31 +77,44 @@ function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.work
 }
 function getPluginPathAndName(moduleName, paths, projects, root) {
     let pluginPath;
-    let shouldRegisterTSTranspiler = false;
-    try {
-        pluginPath = require.resolve(moduleName, {
-            paths,
-        });
-        const extension = path.extname(pluginPath);
-        shouldRegisterTSTranspiler = extension === '.ts';
+    // Resolve local workspace plugins from source first so the workspace's
+    // `customConditions`/`development` exports condition wins over the built
+    // `dist` artifact that Node's resolver would otherwise pick up via the
+    // `default` condition (Node ignores TypeScript custom conditions). Skipped
+    // when `projects` weren't loaded — the caller already determined that the
+    // import isn't a workspace package.
+    const localPlugin = projects
+        ? resolveLocalNxPlugin(moduleName, projects, root)
+        : null;
+    if (localPlugin) {
+        pluginPath = tryResolveLocalPluginFromSource(moduleName, localPlugin, root);
+        if (!pluginPath && getSubpathOfLocalPackage(moduleName, localPlugin)) {
+            throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
+        }
     }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const plugin = resolveLocalNxPlugin(moduleName, projects, root);
-            if (plugin) {
-                shouldRegisterTSTranspiler = true;
-                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
-                pluginPath = main ? path.join(root, main) : plugin.path;
+    if (!pluginPath) {
+        try {
+            pluginPath = require.resolve(moduleName, { paths });
+        }
+        catch (e) {
+            if (localPlugin && isPackageResolutionError(e)) {
+                throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
             }
-            else {
-                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
+            if (e.code !== 'MODULE_NOT_FOUND') {
                 throw e;
             }
-        }
-        else {
+            if (localPlugin) {
+                throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
+            }
+            logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
             throw e;
         }
     }
+    const ext = path.extname(pluginPath);
+    // Directory paths fall through to Node's `package.json` `main` resolution
+    // which may land on a TS file; only opt out of TS transpiler registration
+    // when the resolved path is unambiguously JS.
+    const shouldRegisterTSTranspiler = ext === '' || TS_SOURCE_EXTENSIONS.has(ext);
     const packageJsonPath = path.join(pluginPath, 'package.json');
     const { name } = !['.ts', '.js'].some((x) => path.extname(moduleName) === x) && // Not trying to point to a ts or js file
         (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
@@ -78,12 +122,84 @@ function getPluginPathAndName(moduleName, paths, projects, root) {
         : { name: moduleName };
     return { pluginPath, name, shouldRegisterTSTranspiler };
 }
+function getSubpathOfLocalPackage(moduleName, plugin) {
+    const packageName = plugin.projectConfig.metadata?.js?.packageName;
+    if (!packageName || !moduleName.startsWith(packageName + '/')) {
+        return null;
+    }
+    return '.' + moduleName.slice(packageName.length);
+}
+function tryResolveLocalPluginFromSource(moduleName, plugin, root) {
+    if (plugin.resolvedFile) {
+        return plugin.resolvedFile;
+    }
+    const subpath = getSubpathOfLocalPackage(moduleName, plugin);
+    if (subpath) {
+        return resolveSubpathFromExports(plugin.projectConfig, plugin.path, subpath, root);
+    }
+    const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
+    return main ? path.join(root, main) : null;
+}
+function throwUnresolvableLocalPluginError(moduleName, plugin, root) {
+    const subpath = getSubpathOfLocalPackage(moduleName, plugin);
+    const packageName = plugin.projectConfig.metadata?.js?.packageName;
+    if (subpath) {
+        throw new Error(`Unable to resolve local plugin "${moduleName}". The import targets ` +
+            `the subpath "${subpath}" of the local package "${packageName}", but ` +
+            `the package's "exports" map has no resolvable entry for "${subpath}", ` +
+            `or none of the matched paths exist on disk. Check the "exports" field ` +
+            `in "${path.relative(root, path.join(plugin.path, 'package.json'))}" ` +
+            `and ensure the source file referenced by "${subpath}" exists.`);
+    }
+    throw new Error(`Unable to resolve local plugin "${moduleName}". The local package ` +
+        `"${packageName ?? moduleName}" does not declare a build target with ` +
+        `a "main" source path, and Node could not resolve it either.`);
+}
+function resolveSubpathFromExports(projectConfig, projectPath, subpath, root) {
+    const packageExports = projectConfig.metadata?.js?.packageExports;
+    if (!packageExports) {
+        return null;
+    }
+    const pkg = {
+        name: projectConfig.metadata.js.packageName,
+        exports: packageExports,
+    };
+    try {
+        const matches = (0, resolve_exports_1.resolve)(pkg, subpath, {
+            conditions: (0, typescript_1.getRootTsConfigResolveExportsConditions)(root),
+        });
+        if (!matches || !matches.length) {
+            return null;
+        }
+        for (const match of matches) {
+            const candidate = path.join(projectPath, match);
+            if ((0, node_fs_1.existsSync)(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    catch (e) {
+        logger_1.logger.verbose(`Failed to resolve subpath "${subpath}" of local plugin via package.json exports`, e);
+    }
+    return null;
+}
 function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
-    if (!projectConfig) {
+    const match = findNxProjectForImportPath(importPath, projects, root);
+    if (!match) {
         return null;
     }
-    return { path: path.join(root, projectConfig.root), projectConfig };
+    let resolvedFile;
+    if (match.tsPathFile) {
+        const candidate = path.join(root, match.tsPathFile);
+        if (path.extname(candidate) && (0, node_fs_1.existsSync)(candidate)) {
+            resolvedFile = candidate;
+        }
+    }
+    return {
+        path: path.join(root, match.projectConfig.root),
+        projectConfig: match.projectConfig,
+        resolvedFile,
+    };
 }
 let packageEntryPointsToProjectMap;
 let wildcardEntryPointsToProjectMap;
@@ -101,7 +217,10 @@ function findNxProjectForImportPath(importPath, projects, root = workspace_root_
         for (const tsConfigPath of possibleTsPaths) {
             const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
             if (nxProject) {
-                return projectNameMap.get(nxProject);
+                return {
+                    projectConfig: projectNameMap.get(nxProject),
+                    tsPathFile: tsConfigPath,
+                };
             }
         }
     }
@@ -112,14 +231,14 @@ function findNxProjectForImportPath(importPath, projects, root = workspace_root_
         } = (0, packages_1.getWorkspacePackagesMetadata)(projects));
     }
     if (packageEntryPointsToProjectMap[importPath]) {
-        return packageEntryPointsToProjectMap[importPath];
+        return { projectConfig: packageEntryPointsToProjectMap[importPath] };
     }
     const project = (0, packages_1.matchImportToWildcardEntryPointsToProjectMap)(wildcardEntryPointsToProjectMap, importPath);
     if (project) {
-        return project;
+        return { projectConfig: project };
     }
     logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
-    throw new Error('Unable to resolve local plugin with import path ' + importPath);
+    return null;
 }
 let tsconfigPaths;
 function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {

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

@@ -3,22 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesFromFiles = createNodesFromFiles;
 const error_types_1 = require("../error-types");
 async function createNodesFromFiles(createNodes, configFiles, options, context) {
-    const results = [];
-    const errors = [];
-    await Promise.all(configFiles.map(async (file, idx) => {
+    const settled = await Promise.all(configFiles.map(async (file, idx) => {
         try {
             const value = await createNodes(file, options, {
                 ...context,
                 configFiles,
             }, idx);
-            if (value) {
-                results.push([file, value]);
-            }
+            return value ? { kind: 'value', file, value } : { kind: 'empty' };
         }
         catch (e) {
-            errors.push([file, e]);
+            return { kind: 'error', file, error: e };
         }
     }));
+    const results = [];
+    const errors = [];
+    for (const entry of settled) {
+        if (entry.kind === 'value') {
+            results.push([entry.file, entry.value]);
+        }
+        else if (entry.kind === 'error') {
+            errors.push([entry.file, entry.error]);
+        }
+    }
     if (errors.length > 0) {
         throw new error_types_1.AggregateCreateNodesError(errors, results);
     }

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -61,11 +61,22 @@ class LegacyTaskHistoryLifeCycle {
     }
     printFlakyTasksMessage() {
         if (this.flakyTasks?.length > 0) {
+            const MAX_VISIBLE_FLAKY = 5;
+            const visibleFlaky = this.flakyTasks.length > MAX_VISIBLE_FLAKY + 1
+                ? this.flakyTasks.slice(0, MAX_VISIBLE_FLAKY)
+                : this.flakyTasks;
+            const hiddenCount = this.flakyTasks.length - visibleFlaky.length;
+            const flakyRows = visibleFlaky.map((t) => `  ${t}`);
+            if (hiddenCount > 0) {
+                flakyRows.push(`  ${hiddenCount} more...`);
+            }
             output_1.output.warn({
-                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1
+                    ? 'a flaky task'
+                    : `${this.flakyTasks.length} flaky tasks`}`,
                 bodyLines: [
                     ,
-                    ...this.flakyTasks.map((t) => `  ${t}`),
+                    ...flakyRows,
                     ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
                         ? []
                         : [

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -79,14 +79,25 @@ class TaskHistoryLifeCycle {
     }
     printFlakyTasksMessage() {
         if (this.flakyTasks?.length > 0) {
+            const MAX_VISIBLE_FLAKY = 5;
+            const visibleFlaky = this.flakyTasks.length > MAX_VISIBLE_FLAKY + 1
+                ? this.flakyTasks.slice(0, MAX_VISIBLE_FLAKY)
+                : this.flakyTasks;
+            const hiddenCount = this.flakyTasks.length - visibleFlaky.length;
+            const flakyRows = visibleFlaky.map((hash) => {
+                const taskRun = this.taskRuns.get(hash);
+                return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
+            });
+            if (hiddenCount > 0) {
+                flakyRows.push(`  ${hiddenCount} more...`);
+            }
             output_1.output.warn({
-                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1
+                    ? 'a flaky task'
+                    : `${this.flakyTasks.length} flaky tasks`}`,
                 bodyLines: [
                     ,
-                    ...this.flakyTasks.map((hash) => {
-                        const taskRun = this.taskRuns.get(hash);
-                        return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
-                    }),
+                    ...flakyRows,
                     ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
                         ? []
                         : [

package/dist/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -67,6 +67,12 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
             displayStoppedTasks.add(taskId);
             inProgressTasks.delete(taskId);
         }
+        else if (taskStatus === 2 /* NativeTaskStatus.Skipped */) {
+            // Skipped tasks don't get an endTasks() call; clear them here so the run
+            // summary doesn't treat them as still-in-progress and report Cancelled.
+            tasksToTaskStatus[taskId] = 'skipped';
+            inProgressTasks.delete(taskId);
+        }
     };
     lifeCycle.endTasks = (taskResults) => {
         for (const { task, status, terminalOutput } of taskResults) {
@@ -132,10 +138,13 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
         (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)().printFlakyTasksMessage();
     };
     const printRunOneSummary = ({ failure, cancelled, }) => {
-        // Prints task outputs in the order they were completed
-        // above the summary, since run-one should print all task results.
+        // Print task outputs in completion order above the summary.
         for (const taskId of taskIdsInTheOrderTheyStart) {
             const taskStatus = tasksToTaskStatus[taskId];
+            // Skipped tasks never ran; don't print a misleading `> nx run` header.
+            if (taskStatus === 'skipped') {
+                continue;
+            }
             const terminalOutput = getTerminalOutput(taskId);
             output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
         }

package/dist/src/tasks-runner/run-command.js

@@ -22,6 +22,7 @@ const project_graph_1 = require("../project-graph/project-graph");
 const handle_errors_1 = require("../utils/handle-errors");
 const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const logger_1 = require("../utils/logger");
 const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
 const sync_generators_1 = require("../utils/sync-generators");
@@ -324,6 +325,10 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
     return status;
 }
 async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+    // Kick off the license lookup in the background so it overlaps with task
+    // execution. The log itself is deferred to the print site below so it
+    // never lands in the middle of task output.
+    const nxKeyPromise = (0, nx_key_1.getNxKeyInformation)().catch(() => null);
     const projectNames = projectsToRun.map((t) => t.name);
     const projectNameSet = new Set(projectNames);
     const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
@@ -348,7 +353,9 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
             printSummary();
         }
         await printConfigureAiAgentsDisclaimer();
-        await (0, nx_key_1.printNxKey)();
+        const nxKey = await nxKeyPromise;
+        if (nxKey)
+            logger_1.logger.log((0, nx_key_1.createNxKeyLicenseeInformation)(nxKey));
         return {
             taskResults,
             completed: didCommandComplete(tasks, taskResults),

package/dist/src/tasks-runner/task-orchestrator.js

@@ -29,6 +29,14 @@ const task_env_1 = require("./task-env");
 const tasks_schedule_1 = require("./tasks-schedule");
 const utils_1 = require("./utils");
 const shared_running_task_1 = require("./running-tasks/shared-running-task");
+/**
+ * Resolve a batch executor's per-task result to a TaskStatus. Prefers an
+ * explicit `status` from the executor; falls back to the `success` boolean
+ * for executors that pre-date the `status` field.
+ */
+function resolveBatchTaskStatus(result) {
+    return result.status ?? (result.success ? 'success' : 'failure');
+}
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
@@ -498,11 +506,18 @@ class TaskOrchestrator {
             // Heavy operations (caching, scheduling, complete) happen at batch-end in postRunSteps
             batchProcess.onTaskResults((taskId, result) => {
                 const task = this.taskGraph.tasks[taskId];
-                const status = result.success ? 'success' : 'failure';
-                this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
+                const status = resolveBatchTaskStatus(result);
+                // Append before print so printTaskTerminalOutput finds the PTY already
+                // populated and no-ops; reversing the order writes terminalOutput twice.
                 if (result.terminalOutput) {
                     this.options.lifeCycle.appendTaskOutput(taskId, result.terminalOutput, false);
                 }
+                // Skipped tasks didn't run, so they have no terminal output and don't
+                // need a per-task PTY — calling printTaskTerminalOutput would otherwise
+                // allocate one just to write a cursor-hide escape.
+                if (status !== 'skipped') {
+                    this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
+                }
                 task.startTime = result.startTime;
                 task.endTime = result.endTime;
                 if (result.startTime && result.endTime) {
@@ -516,10 +531,11 @@ class TaskOrchestrator {
                 const task = this.taskGraph.tasks[taskId];
                 task.startTime = result.startTime;
                 task.endTime = result.endTime;
+                const status = resolveBatchTaskStatus(result);
                 return {
-                    code: result.success ? 0 : 1,
+                    code: status === 'success' ? 0 : 1,
                     task,
-                    status: (result.success ? 'success' : 'failure'),
+                    status,
                     terminalOutput: result.terminalOutput,
                 };
             });

package/dist/src/tasks-runner/tasks-schedule.js

@@ -223,9 +223,9 @@ class TasksSchedule {
         }
     }
     canBatchTaskBeScheduled(task, batchTaskGraph) {
-        // task self needs to have parallelism true
+        // task self needs to support parallelism (undefined defaults to parallel)
         // all deps have either completed or belong to the same batch
-        return (task.parallelism === true &&
+        return (task.parallelism !== false &&
             this.taskGraph.dependencies[task.id].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]));
     }
     canBeScheduled(taskId) {
@@ -248,7 +248,7 @@ class TasksSchedule {
         }
         else {
             // if all running tasks support parallelism, can only schedule task with parallelism
-            return this.taskGraph.tasks[taskId].parallelism === true;
+            return this.taskGraph.tasks[taskId].parallelism !== false;
         }
     }
     getEstimatedTaskTimings() {

package/dist/src/utils/ab-testing.js

@@ -21,6 +21,18 @@ const messageOptions = {
             ],
             footer: '\nFree for small teams. Remote caching and task distribution. 2-minute setup: https://nx.dev/nx-cloud',
         },
+        {
+            code: 'cloud-self-healing-remote-cache',
+            message: `Would you like to enable AI-powered Self-Healing CI and Remote Caching?`,
+            initial: 0,
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
+                { value: 'never', name: pc.dim("No, don't ask again") },
+            ],
+            footer: '\nLearn about it at https://nx.dev/nx-cloud',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
     ],
     setupViewLogs: [
         {

package/dist/src/utils/compile-cache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Enables V8's on-disk bytecode cache for the current process.
+ *
+ * Calls `module.enableCompileCache()` with no arguments and lets Node pick
+ * the location, which means Node's standard env vars work transparently:
+ *  - `NODE_COMPILE_CACHE=<dir>`     — override the cache directory.
+ *  - `NODE_DISABLE_COMPILE_CACHE=1` — disable entirely.
+ *
+ * The default location lives under the OS temp dir keyed by V8 version, so
+ * the cache is shared across workspaces and self-invalidates on Node
+ * upgrades — no nx-specific cleanup needed.
+ *
+ * Called at the entry point of every long-lived nx process (main CLI,
+ * daemon, plugin workers) via `enable-compile-cache.ts`, which side-effects
+ * this on import.
+ *
+ * Set `NX_COMPILE_CACHE=false` to opt out without disabling the cache for
+ * non-nx Node processes the way `NODE_DISABLE_COMPILE_CACHE` would.
+ *
+ * No-op on Node versions without the `module.enableCompileCache` API.
+ * Errors are swallowed — the compile cache is a pure performance
+ * optimization and must never break the CLI.
+ */
+export declare function enableCompileCache(...override: [unknown?]): boolean;

package/dist/src/utils/compile-cache.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableCompileCache = enableCompileCache;
+const tslib_1 = require("tslib");
+const nodeModule = tslib_1.__importStar(require("node:module"));
+/**
+ * Enables V8's on-disk bytecode cache for the current process.
+ *
+ * Calls `module.enableCompileCache()` with no arguments and lets Node pick
+ * the location, which means Node's standard env vars work transparently:
+ *  - `NODE_COMPILE_CACHE=<dir>`     — override the cache directory.
+ *  - `NODE_DISABLE_COMPILE_CACHE=1` — disable entirely.
+ *
+ * The default location lives under the OS temp dir keyed by V8 version, so
+ * the cache is shared across workspaces and self-invalidates on Node
+ * upgrades — no nx-specific cleanup needed.
+ *
+ * Called at the entry point of every long-lived nx process (main CLI,
+ * daemon, plugin workers) via `enable-compile-cache.ts`, which side-effects
+ * this on import.
+ *
+ * Set `NX_COMPILE_CACHE=false` to opt out without disabling the cache for
+ * non-nx Node processes the way `NODE_DISABLE_COMPILE_CACHE` would.
+ *
+ * No-op on Node versions without the `module.enableCompileCache` API.
+ * Errors are swallowed — the compile cache is a pure performance
+ * optimization and must never break the CLI.
+ */
+function enableCompileCache(
+// Test seam: production callers omit this. `unknown` (rather than
+// `EnableCompileCacheFn | undefined`) lets tests pass a non-function to
+// simulate pre-22.8 Node where `module.enableCompileCache` is missing. We
+// read `arguments.length` so callers can *explicitly* pass `undefined`.
+...override) {
+    if (process.env.NX_COMPILE_CACHE === 'false')
+        return false;
+    const impl = override.length === 0
+        ? nodeModule.enableCompileCache
+        : override[0];
+    if (typeof impl !== 'function')
+        return false;
+    try {
+        impl();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/utils/enable-compile-cache.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/enable-compile-cache.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Side-effect-only module: import this as the *first* import in any nx
+// process entry point so V8's compile cache is enabled before the rest of
+// the import chain (which is what we actually want to cache) starts loading.
+const compile_cache_1 = require("./compile-cache");
+(0, compile_cache_1.enableCompileCache)();

package/dist/src/utils/has-nx-js-plugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if `@nx/js` is installed by attempting to resolve its `package.json`.
+ *
+ * Lives in its own module so unit tests can `jest.doMock` it without having to
+ * intercept Node's resolver at the global level. The previous in-`package-json`
+ * definition was unreachable to mocks because callers in the same module
+ * referenced it via the local lexical binding rather than `module.exports`.
+ */
+export declare function hasNxJsPlugin(projectRoot: string, workspaceRoot: string): boolean;

package/dist/src/utils/has-nx-js-plugin.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNxJsPlugin = hasNxJsPlugin;
+const installation_directory_1 = require("./installation-directory");
+/**
+ * Checks if `@nx/js` is installed by attempting to resolve its `package.json`.
+ *
+ * Lives in its own module so unit tests can `jest.doMock` it without having to
+ * intercept Node's resolver at the global level. The previous in-`package-json`
+ * definition was unreachable to mocks because callers in the same module
+ * referenced it via the local lexical binding rather than `module.exports`.
+ */
+function hasNxJsPlugin(projectRoot, workspaceRoot) {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@nx/js/package.json', {
+            paths: [projectRoot, ...(0, installation_directory_1.getNxRequirePaths)(workspaceRoot), __dirname],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/utils/logger.d.ts

@@ -1,7 +1,17 @@
 export declare const NX_PREFIX: string;
 export declare const NX_ERROR: string;
+type LogDriver = Pick<Console, 'warn' | 'error' | 'info' | 'log' | 'debug'>;
+export declare function createLogger(driver: LogDriver): {
+    warn: (...v: any[]) => void;
+    error: (s: any) => void;
+    info: (s: any) => void;
+    log: (...s: any[]) => void;
+    debug: (...s: any[]) => void;
+    fatal: (...s: any[]) => void;
+    verbose: (...s: any[]) => void;
+};
 export declare const logger: {
-    warn: (s: any) => void;
+    warn: (...v: any[]) => void;
     error: (s: any) => void;
     info: (s: any) => void;
     log: (...s: any[]) => void;
@@ -10,3 +20,4 @@ export declare const logger: {
     verbose: (...s: any[]) => void;
 };
 export declare function stripIndent(str: string): string;
+export {};