nx 20.8.4 → 22.7.7

package/dist/src/utils/child-process.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcess = void 0;
+exports.getRunNxBaseCommand = getRunNxBaseCommand;
+exports.runNxSync = runNxSync;
+exports.runNxAsync = runNxAsync;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const package_manager_1 = require("./package-manager");
+const workspace_root_1 = require("./workspace-root");
+const exit_codes_1 = require("./exit-codes");
+function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
+        if (!packageManagerCommand) {
+            const pm = (0, package_manager_1.detectPackageManager)();
+            packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm);
+        }
+        return `${packageManagerCommand.exec} nx`;
+    }
+    else {
+        const offsetFromRoot = (0, path_1.relative)(cwd, (0, workspace_root_1.workspaceRootInner)(cwd, null));
+        if (process.platform === 'win32') {
+            return '.\\' + (0, path_1.join)(`${offsetFromRoot}`, 'nx.bat');
+        }
+        else {
+            return './' + (0, path_1.join)(`${offsetFromRoot}`, 'nx');
+        }
+    }
+}
+function runNxSync(cmd, options) {
+    let { packageManagerCommand, ...execSyncOptions } = options ?? {};
+    execSyncOptions.cwd ??= process.cwd();
+    execSyncOptions.windowsHide ??= true;
+    const baseCmd = getRunNxBaseCommand(packageManagerCommand, execSyncOptions.cwd);
+    (0, child_process_1.execSync)(`${baseCmd} ${cmd}`, execSyncOptions);
+}
+async function runNxAsync(cmd, options) {
+    options ??= {};
+    options.cwd ??= process.cwd();
+    let { silent, packageManagerCommand, ...execSyncOptions } = options;
+    silent ??= true;
+    const baseCmd = getRunNxBaseCommand(packageManagerCommand, execSyncOptions.cwd);
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.exec)(`${baseCmd} ${cmd}`, { ...execSyncOptions, windowsHide: true }, (error, stdout, stderr) => {
+            if (error) {
+                reject(stderr || stdout || error.message);
+            }
+            else {
+                resolve();
+            }
+        });
+        if (!silent) {
+            child.stdout?.pipe(process.stdout);
+            child.stderr?.pipe(process.stderr);
+        }
+    });
+}
+class PseudoTtyProcess {
+    constructor(childProcess) {
+        this.childProcess = childProcess;
+        this.isAlive = true;
+        this.exitCallbacks = [];
+        childProcess.onExit((message) => {
+            this.isAlive = false;
+            const exitCode = (0, exit_codes_1.messageToCode)(message);
+            this.exitCallbacks.forEach((cb) => cb(exitCode));
+        });
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+    onOutput(callback) {
+        this.childProcess.onOutput(callback);
+    }
+    kill() {
+        try {
+            this.childProcess.kill();
+        }
+        catch {
+            // when the child process completes before we explicitly call kill, this will throw
+            // do nothing
+        }
+        finally {
+            if (this.isAlive == true) {
+                this.isAlive = false;
+            }
+        }
+    }
+}
+exports.PseudoTtyProcess = PseudoTtyProcess;

package/dist/src/utils/code-frames.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeFrameColumns = codeFrameColumns;
+const tslib_1 = require("tslib");
+// Adapted from https://raw.githubusercontent.com/babel/babel/4108524/packages/babel-code-frame/src/index.js
+const pc = tslib_1.__importStar(require("picocolors"));
+/**
+ * Styles for code frame token types.
+ */
+const defs = {
+    gutter: pc.gray,
+    marker: (text) => pc.red(pc.bold(text)),
+    message: (text) => pc.red(pc.bold(text)),
+};
+/**
+ * RegExp to test for newlines in terminal.
+ */
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+/**
+ * Extract what lines should be marked and highlighted.
+ */
+function getMarkerLines(loc, source, opts = {}) {
+    const startLoc = {
+        column: 0,
+        line: -1,
+        ...loc.start,
+    };
+    const endLoc = {
+        ...startLoc,
+        ...loc.end,
+    };
+    const { linesAbove = 2, linesBelow = 3 } = opts || {};
+    const startLine = startLoc.line;
+    const startColumn = startLoc.column;
+    const endLine = endLoc.line;
+    const endColumn = endLoc.column;
+    let start = Math.max(startLine - (linesAbove + 1), 0);
+    let end = Math.min(source.length, endLine + linesBelow);
+    if (startLine === -1) {
+        start = 0;
+    }
+    if (endLine === -1) {
+        end = source.length;
+    }
+    const lineDiff = endLine - startLine;
+    const markerLines = {};
+    if (lineDiff) {
+        for (let i = 0; i <= lineDiff; i++) {
+            const lineNumber = i + startLine;
+            if (!startColumn) {
+                markerLines[lineNumber] = true;
+            }
+            else if (i === 0) {
+                const sourceLength = source[lineNumber - 1].length;
+                markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+            }
+            else if (i === lineDiff) {
+                markerLines[lineNumber] = [0, endColumn];
+            }
+            else {
+                const sourceLength = source[lineNumber - i].length;
+                markerLines[lineNumber] = [0, sourceLength];
+            }
+        }
+    }
+    else {
+        if (startColumn === endColumn) {
+            if (startColumn) {
+                markerLines[startLine] = [startColumn, 0];
+            }
+            else {
+                markerLines[startLine] = true;
+            }
+        }
+        else {
+            markerLines[startLine] = [startColumn, endColumn - startColumn];
+        }
+    }
+    return { start, end, markerLines };
+}
+function codeFrameColumns(rawLines, loc, opts = {}) {
+    const lines = rawLines.split(NEWLINE);
+    const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
+    const numberMaxWidth = String(end).length;
+    const highlightedLines = opts.highlight ? opts.highlight(rawLines) : rawLines;
+    let frame = highlightedLines
+        .split(NEWLINE)
+        .slice(start, end)
+        .map((line, index) => {
+        const number = start + 1 + index;
+        const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+        const gutter = ` ${paddedNumber} | `;
+        const hasMarker = markerLines[number];
+        if (hasMarker) {
+            let markerLine = '';
+            if (Array.isArray(hasMarker)) {
+                const markerSpacing = line
+                    .slice(0, Math.max(hasMarker[0] - 1, 0))
+                    .replace(/[^\t]/g, ' ');
+                const numberOfMarkers = hasMarker[1] || 1;
+                markerLine = [
+                    '\n ',
+                    defs.gutter(gutter.replace(/\d/g, ' ')),
+                    markerSpacing,
+                    defs.marker('^').repeat(numberOfMarkers),
+                ].join('');
+            }
+            return [defs.marker('>'), defs.gutter(gutter), line, markerLine].join('');
+        }
+        else {
+            return ` ${defs.gutter(gutter)}${line}`;
+        }
+    })
+        .join('\n');
+    return pc.reset(frame);
+}

package/dist/src/utils/collapse-expanded-outputs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Collapses a list of file paths into a smaller set of parent directories
+ * when there are too many outputs to efficiently track individually.
+ *
+ * This prevents creating too many hash files by:
+ * 1. Building a tree structure of all path components
+ * 2. Finding the "collapse level" - the deepest level before exceeding MAX_OUTPUTS_TO_CHECK_HASHES
+ * 3. Returning parent paths at/above collapse level, while preserving leaf paths that terminate early
+ */
+export declare function collapseExpandedOutputs(expandedOutputs: string[]): string[];

package/dist/src/utils/collapse-expanded-outputs.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collapseExpandedOutputs = collapseExpandedOutputs;
+const path_1 = require("path");
+/**
+ * Heuristic to prevent writing too many hash files
+ */
+const MAX_OUTPUTS_TO_CHECK_HASHES = 3;
+/**
+ * Collapses a list of file paths into a smaller set of parent directories
+ * when there are too many outputs to efficiently track individually.
+ *
+ * This prevents creating too many hash files by:
+ * 1. Building a tree structure of all path components
+ * 2. Finding the "collapse level" - the deepest level before exceeding MAX_OUTPUTS_TO_CHECK_HASHES
+ * 3. Returning parent paths at/above collapse level, while preserving leaf paths that terminate early
+ */
+function collapseExpandedOutputs(expandedOutputs) {
+    // Small output sets don't need collapsing
+    if (expandedOutputs.length <= MAX_OUTPUTS_TO_CHECK_HASHES) {
+        return [...expandedOutputs];
+    }
+    const tree = [];
+    // Create a Tree of directories/files
+    for (const output of expandedOutputs) {
+        const pathParts = [];
+        pathParts.unshift(output);
+        let dir = (0, path_1.dirname)(output);
+        while (dir !== (0, path_1.dirname)(dir)) {
+            pathParts.unshift(dir);
+            dir = (0, path_1.dirname)(dir);
+        }
+        for (let i = 0; i < pathParts.length; i++) {
+            tree[i] ??= new Set();
+            tree[i].add(pathParts[i]);
+        }
+    }
+    // Find collapse level: the level before the first level with too many outputs
+    let collapseLevel = tree.length - 1;
+    for (let j = 0; j < tree.length; j++) {
+        if (tree[j].size > MAX_OUTPUTS_TO_CHECK_HASHES) {
+            collapseLevel = Math.max(0, j - 1);
+            break;
+        }
+    }
+    // Collect paths, preserving leaf paths that terminate before collapse level
+    const result = new Set();
+    // Convert sets to arrays once for faster iteration
+    const levelArrays = [];
+    for (let i = 0; i <= collapseLevel + 1 && i < tree.length; i++) {
+        levelArrays[i] = Array.from(tree[i]);
+    }
+    for (let level = 0; level <= collapseLevel; level++) {
+        const nextLevelArray = levelArrays[level + 1];
+        for (const path of levelArrays[level]) {
+            let hasChildren = false;
+            if (nextLevelArray) {
+                for (const child of nextLevelArray) {
+                    if (child.startsWith(path + '/')) {
+                        hasChildren = true;
+                        break;
+                    }
+                }
+            }
+            // Include path if it's at collapse level or doesn't have children (leaf)
+            if (level === collapseLevel || !hasChildren) {
+                result.add(path);
+            }
+        }
+    }
+    return Array.from(result);
+}

package/dist/src/utils/command-line-utils.d.ts

@@ -0,0 +1,57 @@
+import type { Arguments } from 'yargs';
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+export interface RawNxArgs extends NxArgs {
+    prod?: boolean;
+}
+export interface NxArgs {
+    targets?: string[];
+    configuration?: string;
+    /**
+     * @deprecated Custom task runners will be replaced by a new API starting with Nx 21. More info: https://nx.dev/deprecated/custom-tasks-runner
+     */
+    runner?: string;
+    parallel?: number;
+    untracked?: boolean;
+    uncommitted?: boolean;
+    all?: boolean;
+    base?: string;
+    head?: string;
+    exclude?: string[];
+    files?: string[];
+    verbose?: boolean;
+    help?: boolean;
+    version?: boolean;
+    plain?: boolean;
+    projects?: string[];
+    select?: string;
+    graph?: string | boolean;
+    skipNxCache?: boolean;
+    skipRemoteCache?: boolean;
+    outputStyle?: string;
+    tui?: boolean;
+    nxBail?: boolean;
+    nxIgnoreCycles?: boolean;
+    type?: string;
+    batch?: boolean;
+    excludeTaskDependencies?: boolean;
+    skipSync?: boolean;
+    sortRootTsconfigPaths?: boolean;
+}
+export declare function createOverrides(__overrides_unparsed__?: string[]): Record<string, any>;
+export declare function getBaseRef(nxJson: NxJsonConfiguration): string;
+export declare function splitArgsIntoNxArgsAndOverrides(args: {
+    [k: string]: any;
+}, mode: 'run-one' | 'run-many' | 'affected' | 'print-affected', options: {
+    printWarnings: boolean;
+}, nxJson: NxJsonConfiguration): {
+    nxArgs: NxArgs;
+    overrides: Arguments & {
+        __overrides_unparsed__: string[];
+    };
+};
+export declare function parseFiles(options: NxArgs): {
+    files: string[];
+};
+export declare function getProjectRoots(projectNames: string[], { nodes }: ProjectGraph): string[];
+export declare function readGraphFileFromGraphArg({ graph }: Pick<NxArgs, 'graph'>): string;

package/dist/src/utils/command-line-utils.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOverrides = createOverrides;
+exports.getBaseRef = getBaseRef;
+exports.splitArgsIntoNxArgsAndOverrides = splitArgsIntoNxArgsAndOverrides;
+exports.parseFiles = parseFiles;
+exports.getProjectRoots = getProjectRoots;
+exports.readGraphFileFromGraphArg = readGraphFileFromGraphArg;
+const tslib_1 = require("tslib");
+const yargs_parser_1 = tslib_1.__importDefault(require("yargs-parser"));
+const file_utils_1 = require("../project-graph/file-utils");
+const output_1 = require("./output");
+const child_process_1 = require("child_process");
+const workspace_root_1 = require("./workspace-root");
+const shared_options_1 = require("../command-line/yargs-utils/shared-options");
+function createOverrides(__overrides_unparsed__ = []) {
+    let overrides = (0, yargs_parser_1.default)(__overrides_unparsed__, {
+        configuration: {
+            'camel-case-expansion': false,
+            'dot-notation': true,
+        },
+    }) || {};
+    if (!overrides._ || overrides._.length === 0) {
+        delete overrides._;
+    }
+    overrides.__overrides_unparsed__ = __overrides_unparsed__;
+    return overrides;
+}
+function getBaseRef(nxJson) {
+    return nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+}
+function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings: true }, nxJson) {
+    // this is to lerna case when this function is invoked imperatively
+    if (args['target'] && !args['targets']) {
+        args['targets'] = [args['target']];
+    }
+    delete args['target'];
+    delete args['t'];
+    if (!args.__overrides_unparsed__ && args._) {
+        // required for backwards compatibility
+        args.__overrides_unparsed__ = args._;
+        delete args._;
+    }
+    // This handles the way Lerna passes in overrides
+    if (!args.__overrides_unparsed__ && args.__overrides__) {
+        // required for backwards compatibility
+        args.__overrides_unparsed__ = args.__overrides__;
+        delete args._;
+    }
+    const nxArgs = args;
+    let overrides = createOverrides(args.__overrides_unparsed__);
+    delete nxArgs.$0;
+    delete nxArgs.__overrides_unparsed__;
+    if (mode === 'run-many') {
+        const args = nxArgs;
+        if (!args.projects) {
+            args.projects = [];
+        }
+        else if (typeof args.projects === 'string') {
+            args.projects = args.projects.split(',');
+        }
+    }
+    if (nxArgs.prod) {
+        delete nxArgs.prod;
+        nxArgs.configuration = 'production';
+    }
+    if (mode === 'affected') {
+        if (options.printWarnings && nxArgs.all) {
+            output_1.output.warn({
+                title: `Running affected:* commands with --all can result in very slow builds.`,
+                bodyLines: [
+                    `${output_1.output.bold('--all')} is not meant to be used for any sizable project or to be used in CI.`,
+                    '',
+                    `${output_1.output.dim('Learn more about checking only what is affected: https://nx.dev/nx/affected')}`,
+                ],
+            });
+        }
+        // Allow setting base and head via environment variables (lower priority than direct command arguments)
+        if (!nxArgs.base && process.env.NX_BASE) {
+            nxArgs.base = process.env.NX_BASE;
+            if (options.printWarnings) {
+                output_1.output.note({
+                    title: `No explicit --base argument provided, but found environment variable NX_BASE so using its value as the affected base: ${output_1.output.bold(`${nxArgs.base}`)}`,
+                });
+            }
+        }
+        if (!nxArgs.head && process.env.NX_HEAD) {
+            nxArgs.head = process.env.NX_HEAD;
+            if (options.printWarnings) {
+                output_1.output.note({
+                    title: `No explicit --head argument provided, but found environment variable NX_HEAD so using its value as the affected head: ${output_1.output.bold(`${nxArgs.head}`)}`,
+                });
+            }
+        }
+        if (!nxArgs.base) {
+            nxArgs.base = getBaseRef(nxJson);
+            // No user-provided arguments to set the affected criteria, so inform the user of the defaults being used
+            if (options.printWarnings &&
+                !nxArgs.head &&
+                !nxArgs.files &&
+                !nxArgs.uncommitted &&
+                !nxArgs.untracked &&
+                !nxArgs.all) {
+                output_1.output.note({
+                    title: `Affected criteria defaulted to --base=${output_1.output.bold(`${nxArgs.base}`)} --head=${output_1.output.bold('HEAD')}`,
+                });
+            }
+        }
+        if (nxArgs.base) {
+            nxArgs.base = getMergeBase(nxArgs.base, nxArgs.head);
+        }
+    }
+    if (typeof args.exclude === 'string') {
+        nxArgs.exclude = args.exclude.split(',');
+    }
+    if (!nxArgs.skipNxCache) {
+        nxArgs.skipNxCache =
+            process.env.NX_SKIP_NX_CACHE === 'true' ||
+                process.env.NX_DISABLE_NX_CACHE === 'true';
+    }
+    if (!nxArgs.skipRemoteCache) {
+        nxArgs.skipRemoteCache =
+            process.env.NX_DISABLE_REMOTE_CACHE === 'true' ||
+                process.env.NX_SKIP_REMOTE_CACHE === 'true';
+    }
+    normalizeNxArgsRunner(nxArgs, nxJson, options);
+    nxArgs['parallel'] = (0, shared_options_1.readParallelFromArgsAndEnv)(args);
+    return { nxArgs, overrides };
+}
+function normalizeNxArgsRunner(nxArgs, nxJson, options) {
+    if (!nxArgs.runner) {
+        const envKey = 'NX_TASKS_RUNNER';
+        const runner = process.env[envKey];
+        if (runner) {
+            const runnerExists = nxJson.tasksRunnerOptions?.[runner];
+            if (options.printWarnings) {
+                if (runnerExists) {
+                    output_1.output.note({
+                        title: `No explicit --runner argument provided, but found environment variable ${envKey} so using its value: ${output_1.output.bold(`${runner}`)}`,
+                    });
+                }
+                else if (nxArgs.verbose ||
+                    process.env.NX_VERBOSE_LOGGING === 'true') {
+                    output_1.output.warn({
+                        title: `Could not find ${output_1.output.bold(`${runner}`)} within \`nx.json\` tasksRunnerOptions.`,
+                        bodyLines: [
+                            `${output_1.output.bold(`${runner}`)} was set by ${envKey}`,
+                            ``,
+                            `To suppress this message, either:`,
+                            `  - provide a valid task runner with --runner`,
+                            `  - ensure NX_TASKS_RUNNER matches a task runner defined in nx.json`,
+                        ],
+                    });
+                }
+            }
+            if (runnerExists) {
+                nxArgs.runner = runner;
+            }
+        }
+    }
+}
+function parseFiles(options) {
+    const { files, uncommitted, untracked, base, head } = options;
+    if (files) {
+        return {
+            files,
+        };
+    }
+    else if (uncommitted) {
+        return {
+            files: getUncommittedFiles(),
+        };
+    }
+    else if (untracked) {
+        return {
+            files: getUntrackedFiles(),
+        };
+    }
+    else if (base && head) {
+        return {
+            files: getFilesUsingBaseAndHead(base, head),
+        };
+    }
+    else if (base) {
+        return {
+            files: Array.from(new Set([
+                ...getFilesUsingBaseAndHead(base, 'HEAD'),
+                ...getUncommittedFiles(),
+                ...getUntrackedFiles(),
+            ])),
+        };
+    }
+}
+function getUncommittedFiles() {
+    return parseGitOutput(`git diff --name-only --no-renames --relative HEAD .`);
+}
+function getUntrackedFiles() {
+    return parseGitOutput(`git ls-files --others --exclude-standard`);
+}
+function getMergeBase(base, head = 'HEAD') {
+    try {
+        return (0, child_process_1.execSync)(`git merge-base "${base}" "${head}"`, {
+            maxBuffer: file_utils_1.TEN_MEGABYTES,
+            cwd: workspace_root_1.workspaceRoot,
+            stdio: 'pipe',
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        try {
+            return (0, child_process_1.execSync)(`git merge-base --fork-point "${base}" "${head}"`, {
+                maxBuffer: file_utils_1.TEN_MEGABYTES,
+                cwd: workspace_root_1.workspaceRoot,
+                stdio: 'pipe',
+                windowsHide: true,
+            })
+                .toString()
+                .trim();
+        }
+        catch {
+            return base;
+        }
+    }
+}
+function getFilesUsingBaseAndHead(base, head) {
+    return parseGitOutput(`git diff --name-only --no-renames --relative "${base}" "${head}"`);
+}
+function parseGitOutput(command) {
+    return (0, child_process_1.execSync)(command, {
+        maxBuffer: file_utils_1.TEN_MEGABYTES,
+        cwd: workspace_root_1.workspaceRoot,
+        stdio: 'pipe',
+        windowsHide: true,
+    })
+        .toString('utf-8')
+        .split('\n')
+        .map((a) => a.trim())
+        .filter((a) => a.length > 0);
+}
+function getProjectRoots(projectNames, { nodes }) {
+    return projectNames.map((name) => nodes[name].data.root);
+}
+function readGraphFileFromGraphArg({ graph }) {
+    return typeof graph === 'string' && graph !== 'true' && graph !== ''
+        ? graph
+        : undefined;
+}

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/consume-messages-from-socket.d.ts

@@ -0,0 +1,9 @@
+export declare const MESSAGE_END_SEQ: string;
+export declare function consumeMessagesFromSocket(callback: (message: string) => void): (data: any) => void;
+export declare function isJsonMessage(message: string): boolean;
+/**
+ * Parse a message that was produced by `serialize()` in
+ * `daemon/socket-utils.ts`. Auto-detects JSON vs. v8-serialized payloads using
+ * `isJsonMessage()` and decodes the binary path via `v8.deserialize`.
+ */
+export declare function parseMessage<T = unknown>(message: string): T;