nx 23.3.0-beta.0 → 23.3.0-beta.2

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

@@ -37,9 +37,22 @@ const utils_1 = require("./utils");
 function resolveBatchTaskStatus(result) {
     return result.status ?? (result.success ? 'success' : 'failure');
 }
+/** Whether a path names a file with bytes in it. */
+function hasContent(path) {
+    try {
+        return (0, fs_1.statSync)(path).size > 0;
+    }
+    catch {
+        return false;
+    }
+}
 class TaskOrchestrator {
     // endregion internal state
-    constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, fullTaskGraph = taskGraph) {
+    constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, 
+    /** What the user named; undefined means they named nothing. */
+    specifiedOutputStyle, 
+    /** What this run renders with, after defaults. */
+    resolvedOutputStyle, fullTaskGraph = taskGraph) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.initiatingTasks = initiatingTasks;
@@ -49,7 +62,8 @@ class TaskOrchestrator {
         this.options = options;
         this.bail = bail;
         this.daemon = daemon;
-        this.outputStyle = outputStyle;
+        this.specifiedOutputStyle = specifiedOutputStyle;
+        this.resolvedOutputStyle = resolvedOutputStyle;
         this.fullTaskGraph = fullTaskGraph;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
@@ -106,6 +120,13 @@ class TaskOrchestrator {
         this.continuousTaskExitHandled = new Map();
         this.cleanupPromise = null;
         this.signalHandlers = [];
+        // Tasks whose runner already owns the write to
+        // `<cacheDir>/terminalOutputs/<hash>` — forked processes write it as they
+        // exit, and the paths that never spawn one write it inline. The backstop in
+        // postRunSteps consults this so a task's output is written exactly once.
+        this.tasksWithPersistedOutput = new Set();
+        /** Batches whose worker log was handed to the life cycle, so it must survive. */
+        this.announcedBatchLogs = new Set();
     }
     async init() {
         this.setupSignalHandlers();
@@ -158,6 +179,10 @@ class TaskOrchestrator {
         perf_hooks_1.performance.measure('task-execution', 'task-execution:start', 'task-execution:end');
         if (!this.stopRequested) {
             this.cache.removeOldCacheRecords();
+            // Free function, not a cache method: `BatchProcess` writes these logs
+            // whichever cache implementation is active. It no-ops under WASM, where
+            // the native half does not exist.
+            (0, cache_1.sweepBatchOutputs)();
         }
         await this.cleanup();
         await this.dispose();
@@ -586,7 +611,7 @@ class TaskOrchestrator {
         const runBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:start');
         let batchProcess;
         try {
-            batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.fullTaskGraph, env);
+            batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.fullTaskGraph, env, (0, output_1.printsTaskOutput)(this.resolvedOutputStyle));
             // Stream output from batch process to the batch
             batchProcess.onOutput((output) => {
                 this.options.lifeCycle.appendBatchOutput?.(batch.id, output);
@@ -633,9 +658,13 @@ class TaskOrchestrator {
                     terminalOutput: result.terminalOutput,
                 };
             });
+            // The capture stream buffers, so both readers below would otherwise be
+            // racing bytes that have not reached the file yet.
+            await batchProcess.flushCapturedOutput();
             if ((0, output_1.shouldGroupBatchOutput)()) {
                 this.renderBatchOutputSafely(batch.id, () => this.printGroupedBatchOutput(batch, taskResults, batchProcess.getCapturedOutputPath()));
             }
+            this.announceBatchWorkerLog(batch.id, taskResults, batchProcess.getCapturedOutputPath());
             return taskResults;
         }
         catch (e) {
@@ -652,15 +681,19 @@ class TaskOrchestrator {
                     terminalOutput: isBatchStopping ? '' : (e.stack ?? e.message ?? ''),
                 };
             });
+            await batchProcess?.flushCapturedOutput();
+            this.announceBatchWorkerLog(batch.id, taskResults, batchProcess?.getCapturedOutputPath());
             // The worker died without reporting results, so nothing was attributed to
             // a task and no per-task output ran. Everything it wrote went to
-            // stdout/stderr, held back under log grouping — surface it as one fold.
-            // Outside grouping it already streamed live. This matters just as much
-            // when the batch was stopped: every task is marked stopped whether or not
-            // it finished, so the log is the only record of what got through. Only
-            // the exit-code error is dropped there, since it restates the
-            // cancellation.
-            if ((0, output_1.shouldGroupBatchOutput)()) {
+            // stdout/stderr, held back under grouping - surface it as one fold. Under
+            // a style that prints nothing there is no fold; the log is announced by
+            // path above instead. Outside both, it already streamed live. This
+            // matters just as much when the batch was stopped: every task
+            // is marked stopped whether or not it finished, so the log is the only
+            // record of what got through. Only the exit-code error is dropped there,
+            // since it restates the cancellation.
+            if ((0, output_1.shouldGroupBatchOutput)() &&
+                (0, output_1.printsTaskOutput)(this.resolvedOutputStyle)) {
                 const capturedOutputPath = batchProcess?.getCapturedOutputPath();
                 const trailer = isBatchStopping ? undefined : e.message;
                 if (capturedOutputPath || trailer) {
@@ -673,11 +706,42 @@ class TaskOrchestrator {
             return taskResults;
         }
         finally {
-            batchProcess?.discardCapturedOutput();
+            // Kept only when something failed and the log was announced; an all-green
+            // batch's chatter explains nothing and would sit in `batchOutputs/` until
+            // the sweep.
+            if (!this.announcedBatchLogs.has(batch.id)) {
+                batchProcess?.discardCapturedOutput();
+            }
             const runBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:end');
             perf_hooks_1.performance.measure('TaskOrchestrator-run-batch', runBatchStart.name, runBatchEnd.name);
         }
     }
+    /**
+     * Tells the life cycle where the batch worker's own log is, when something
+     * failed and a style that prints nothing would otherwise leave it unread.
+     *
+     * The path is announced rather than the bytes copied into a task: one worker
+     * produces one log, it explains the batch rather than any single task, and a
+     * task's own output file is read back verbatim on a cache hit.
+     */
+    announceBatchWorkerLog(batchId, results, capturedOutputPath) {
+        if (!capturedOutputPath || (0, output_1.printsTaskOutput)(this.resolvedOutputStyle)) {
+            return;
+        }
+        const failed = results.some((r) => r.status === 'failure' || r.status === 'stopped');
+        if (!failed) {
+            return;
+        }
+        // The path is minted when the file is opened, before any byte reaches it,
+        // so a capture that failed on its first write leaves one that exists and is
+        // empty. Announcing that offers the reader an address holding nothing.
+        // Checked after the flush, so the size is what a reader will actually see.
+        if (!hasContent(capturedOutputPath)) {
+            return;
+        }
+        this.announcedBatchLogs.add(batchId);
+        this.options.lifeCycle.batchOutputAvailable?.(batchId, capturedOutputPath);
+    }
     /**
      * Rendering a batch's output must never change the batch's results. A throw
      * from the printer would otherwise land in `runBatch`'s own error handling:
@@ -741,17 +805,20 @@ class TaskOrchestrator {
      * A batch that never reported results is handled by the caller instead.
      */
     printGroupedBatchOutput(batch, taskResults, capturedOutputPath) {
-        // Read from the same field the streaming decision uses. `this.options` has
-        // its own `outputStyle`, merged from `nx.json`'s tasksRunnerOptions, so the
-        // two disagree whenever a style is configured there but not named on the
-        // command line - and `init-tasks-runner` passes a populated `options` with
-        // no style argument at all, so on that path only `options` can carry one.
+        // Reads `resolvedOutputStyle` - what the run actually renders with. The
+        // streaming decision deliberately reads `specifiedOutputStyle` instead,
+        // since it has to tell a named style from an inferred default. `this.options`
+        // has its own `outputStyle`, merged from `nx.json`'s tasksRunnerOptions, so
+        // the two disagree whenever a style is configured there but not named on the
+        // command line.
         const printsFullOutput = (0, output_1.printsFullTaskOutput)({
             verbose: this.options.verbose,
-            outputStyle: this.outputStyle,
+            outputStyle: this.resolvedOutputStyle,
         });
         const batchOwnsTheDiagnostic = taskResults.some((r) => r.status === 'failure' || r.status === 'stopped');
-        if ((printsFullOutput || batchOwnsTheDiagnostic) && capturedOutputPath) {
+        if ((0, output_1.printsTaskOutput)(this.resolvedOutputStyle) &&
+            (printsFullOutput || batchOwnsTheDiagnostic) &&
+            capturedOutputPath) {
             // No redirect lines: every task renders itself below, so there is nothing
             // to redirect anyone to.
             this.printBatchFold(batch, taskResults, { capturedOutputPath }, { redirectLines: false });
@@ -866,6 +933,10 @@ class TaskOrchestrator {
         if (this.completedTasks.has(task.id))
             return;
         const terminalOutput = e?.message ?? '';
+        // The worker rejected, so whatever the runner was going to leave on disk
+        // either never landed or can't be trusted. Hand the file back to
+        // postRunSteps so the failure itself is what the task's output path holds.
+        this.tasksWithPersistedOutput.delete(task.id);
         this.options.lifeCycle.printTaskTerminalOutput(task, 'failure', terminalOutput);
         await this.postRunSteps([{ task, status: 'failure', terminalOutput }], doNotSkipCache, groupId);
     }
@@ -880,7 +951,12 @@ class TaskOrchestrator {
         await this.preRunSteps([task], { groupId });
         const pipeOutput = await this.pipeOutputCapture(task);
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        const streamOutput = (0, output_1.isStaticOutputStyle)(this.outputStyle)
+        // `summary` prints log paths rather than logs, and `shouldStreamOutput`
+        // would otherwise stream the initiating project's output in full - the one
+        // task a run-one is most likely to have. Continuous tasks are deliberately
+        // NOT suppressed the same way; see `startContinuousTask`.
+        const streamOutput = (0, output_1.isStaticOutputStyle)(this.specifiedOutputStyle) ||
+            !(0, output_1.printsTaskOutput)(this.resolvedOutputStyle)
             ? false
             : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
         const env = pipeOutput
@@ -970,13 +1046,18 @@ class TaskOrchestrator {
                         });
                     }
                 }
-                if (!streamOutput && !shouldPrefix) {
-                    // TODO: shouldn't this be checking if the task is continuous before writing anything to disk or calling printTaskTerminalOutput?
-                    runningTask.onExit((code, terminalOutput) => {
+                runningTask.onExit((code, terminalOutput) => {
+                    if (!streamOutput && !shouldPrefix) {
                         this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                    }
+                    // A continuous task never reaches postRunSteps, so exiting is its
+                    // only chance to leave its output on disk. A discrete one is written
+                    // there instead, whatever its output style — writing here too would
+                    // just duplicate it.
+                    if (task.continuous) {
                         (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
-                    });
-                }
+                    }
+                });
                 return runningTask;
             }
             catch (e) {
@@ -988,6 +1069,7 @@ class TaskOrchestrator {
                 }
                 const terminalOutput = e.stack ?? e.message ?? '';
                 (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                this.tasksWithPersistedOutput.add(task.id);
                 return new noop_child_process_1.NoopChildProcess({
                     code: 1,
                     terminalOutput,
@@ -996,6 +1078,7 @@ class TaskOrchestrator {
         }
         else if (targetConfiguration.executor === 'nx:noop') {
             (0, fs_1.writeFileSync)(temporaryOutputPath, '');
+            this.tasksWithPersistedOutput.add(task.id);
             return new noop_child_process_1.NoopChildProcess({
                 code: 0,
                 terminalOutput: '',
@@ -1004,6 +1087,12 @@ class TaskOrchestrator {
         else {
             // cache prep
             const runningTask = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+            // Every forked path leaves the file behind whatever the output style:
+            // the pseudo-terminal and prefixed processes write it when they exit,
+            // the direct-output capture has the child write it itself, and the
+            // fork-failure fallback writes the error. Continuous tasks depend on
+            // that — they never reach postRunSteps.
+            this.tasksWithPersistedOutput.add(task.id);
             if (this.tuiEnabled) {
                 if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
                     // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
@@ -1056,9 +1145,14 @@ class TaskOrchestrator {
             if (process.env.NX_VERBOSE_LOGGING === 'true') {
                 console.error(e);
             }
+            const terminalOutput = e.stack ?? e.message ?? '';
+            // No process ever started, so nothing else will write the file. Record
+            // why, so the task's terminal output path resolves to the fork error
+            // rather than to nothing.
+            (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
             return new noop_child_process_1.NoopChildProcess({
                 code: 1,
-                terminalOutput: e.stack ?? e.message ?? '',
+                terminalOutput,
             });
         }
     }
@@ -1091,7 +1185,13 @@ class TaskOrchestrator {
         const pipeOutput = await this.pipeOutputCapture(task);
         // obtain metadata
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        const streamOutput = (0, output_1.isStaticOutputStyle)(this.outputStyle)
+        // Deliberately not gated on `printsTaskOutput`, unlike `runTaskDirectly`.
+        // `SummaryTerminalOutputLifeCycle.printTaskTerminalOutput` is a no-op and it
+        // only reports at `endCommand`, which never runs for a task that does not
+        // end - so suppressing here would leave a `nx serve` under `summary` with a
+        // permanently silent terminal and no file to read yet. Streaming is the only
+        // channel a continuous task has.
+        const streamOutput = (0, output_1.isStaticOutputStyle)(this.specifiedOutputStyle)
             ? false
             : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
         let env = pipeOutput
@@ -1108,6 +1208,9 @@ class TaskOrchestrator {
         this.continuousTaskExitHandled.set(task.id, new Promise((resolve) => {
             childProcess.onExit(async (code) => {
                 await this.handleContinuousTaskExit(code, task, groupId, true);
+                // Registered after the runner's own exit handler, which is what
+                // wrote the file.
+                this.recordContinuousTerminalOutput(task);
                 resolve();
             });
         }));
@@ -1143,34 +1246,117 @@ class TaskOrchestrator {
         // Caller decides whether these results should be written to the cache.
         // Cache replays pass false so a replayed failure (reported as 'failure' so
         // it counts as a failed run) isn't re-written to the cache on every replay.
-        if (shouldCache && !this.stopRequested) {
+        const resultsToCache = shouldCache && !this.stopRequested ? this.resultsToCache(results) : [];
+        // Resolved before the cache writes so the two never write the same file.
+        this.persistTerminalOutputs(results, resultsToCache);
+        if (resultsToCache.length > 0) {
             // cache the results
             perf_hooks_1.performance.mark('cache-results-start');
-            await Promise.all(results
-                .filter(({ status }) => status !== 'local-cache' &&
-                status !== 'local-cache-kept-existing' &&
-                status !== 'remote-cache' &&
-                status !== 'skipped' &&
-                status !== 'stopped')
-                .map((result) => ({
-                ...result,
-                code: result.status === 'local-cache' ||
-                    result.status === 'local-cache-kept-existing' ||
-                    result.status === 'remote-cache' ||
-                    result.status === 'success'
-                    ? 0
-                    : 1,
-                outputs: result.task.outputs,
-            }))
-                .filter(({ task, code }) => this.shouldCacheTaskResult(task, code))
-                .filter(({ terminalOutput, outputs }) => terminalOutput || outputs)
-                .map(async ({ task, code, terminalOutput, outputs }) => this.cache.put(task, terminalOutput, outputs, code)));
+            await Promise.all(resultsToCache.map(async ({ task, code, terminalOutput, outputs }) => this.cache.put(task, terminalOutput, outputs, code)));
             perf_hooks_1.performance.mark('cache-results-end');
             perf_hooks_1.performance.measure('cache-results', 'cache-results-start', 'cache-results-end');
         }
         await this.complete(results, groupId);
         await this.scheduleNextTasksAndReleaseThreads();
     }
+    /**
+     * The results `cache.put` will write, in the shape it wants them. Pulled out
+     * of postRunSteps so the terminal-output backstop can be told exactly which
+     * tasks the cache is already writing a file for.
+     */
+    resultsToCache(results) {
+        return results
+            .filter(({ status }) => status !== 'local-cache' &&
+            status !== 'local-cache-kept-existing' &&
+            status !== 'remote-cache' &&
+            status !== 'skipped' &&
+            status !== 'stopped')
+            .map((result) => ({
+            ...result,
+            code: result.status === 'local-cache' ||
+                result.status === 'local-cache-kept-existing' ||
+                result.status === 'remote-cache' ||
+                result.status === 'success'
+                ? 0
+                : 1,
+            outputs: result.task.outputs,
+        }))
+            .filter(({ task, code }) => this.shouldCacheTaskResult(task, code))
+            .filter(({ terminalOutput, outputs }) => terminalOutput || outputs);
+    }
+    /**
+     * Guarantee that every task that actually ran leaves its terminal output at
+     * `<cacheDir>/terminalOutputs/<hash>`, whatever its cache setting, output
+     * style, or batch membership. That path is what `--output-style=summary`
+     * addresses each failure by, what the DB cache reads back on a hit
+     * (`build_cached_result`), and what Nx Cloud falls back to reading when a
+     * task's in-memory output is undefined, so a task that reaches a terminal
+     * state without a file there is a dangling reference.
+     *
+     * Batch tasks are why this exists. Their output only ever arrives over IPC,
+     * so the sole thing that ever put it on disk was `cache.put` — leaving a
+     * `cache:false` batch task (the shape CI runs under `NX_BATCH_MODE`) with no
+     * file at all.
+     *
+     * Written exactly once per task: tasks whose runner owns the file are
+     * recorded in `tasksWithPersistedOutput`, and tasks `cache.put` is about to
+     * write are skipped here. Cache hits are skipped by status — their output was
+     * read from this very file — except a replayed cached *failure*, which comes
+     * back as `failure` and is rewritten with the bytes it was just read with.
+     * Skipped tasks never ran, so there is nothing to write.
+     *
+     * Every file written without a cache entry behind it is then registered with
+     * the cache, because `removeOldCacheRecords` only collects hashes it finds in
+     * the database — an unregistered file would never be cleaned up. That covers
+     * files this method wrote AND ones a runner wrote, which are equally
+     * invisible to the GC.
+     */
+    persistTerminalOutputs(results, resultsToCache) {
+        const writtenByCache = new Set(resultsToCache.map(({ task }) => task.id));
+        const toRecord = [];
+        for (const { task, status, terminalOutput } of results) {
+            if (terminalOutput === undefined ||
+                // A task that failed before it was hashed has no path to write to.
+                !task.hash ||
+                status === 'skipped' ||
+                status === 'local-cache' ||
+                status === 'local-cache-kept-existing' ||
+                status === 'remote-cache' ||
+                // `cache.put` writes the file and records the hash itself.
+                writtenByCache.has(task.id)) {
+                continue;
+            }
+            if (!this.tasksWithPersistedOutput.has(task.id)) {
+                this.tasksWithPersistedOutput.add(task.id);
+                (0, fs_1.writeFileSync)(this.cache.temporaryOutputPath(task), terminalOutput);
+            }
+            toRecord.push({
+                hash: task.hash,
+                size: Buffer.byteLength(terminalOutput),
+            });
+        }
+        if (toRecord.length > 0) {
+            this.cache.recordTerminalOutputs(toRecord);
+        }
+    }
+    /**
+     * Register a continuous task's terminal output with the cache so the GC can
+     * collect it. Continuous tasks never reach postRunSteps — their file is
+     * written by whichever runner ran them, as the process exits — so this is
+     * the only place their hash gets recorded. Read off disk rather than from a
+     * result, because a continuous task completes without one.
+     */
+    recordContinuousTerminalOutput(task) {
+        if (!task.hash)
+            return;
+        try {
+            const { size } = (0, fs_1.statSync)(this.cache.temporaryOutputPath(task));
+            this.cache.recordTerminalOutputs([{ hash: task.hash, size }]);
+        }
+        catch {
+            // Exit handler: a throw here would be an unhandled rejection.
+        }
+    }
     async scheduleNextTasksAndReleaseThreads() {
         if (this.stopRequested) {
             this.waitingForTasks.forEach((f) => f(null));

package/dist/src/tasks-runner/terminal-output-path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Where a task's terminal output lives on disk, for callers that have a hash but
+ * no cache instance. Mirrors the native layout (`get_task_outputs_path_internal`
+ * in cache.rs) and the legacy cache's `terminalOutputsDir`; both resolve
+ * `<cacheDir>/terminalOutputs/<hash>`.
+ *
+ * Its own module rather than part of `cache.ts` so the graph and plugin paths
+ * can resolve a path without pulling the cache — and the database, cloud and
+ * task-IO modules behind it — into their import graph.
+ */
+export declare function terminalOutputPathForHash(hash: string): string;

package/dist/src/tasks-runner/terminal-output-path.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminalOutputPathForHash = terminalOutputPathForHash;
+const path_1 = require("path");
+const cache_directory_1 = require("../utils/cache-directory");
+/**
+ * Where a task's terminal output lives on disk, for callers that have a hash but
+ * no cache instance. Mirrors the native layout (`get_task_outputs_path_internal`
+ * in cache.rs) and the legacy cache's `terminalOutputsDir`; both resolve
+ * `<cacheDir>/terminalOutputs/<hash>`.
+ *
+ * Its own module rather than part of `cache.ts` so the graph and plugin paths
+ * can resolve a path without pulling the cache — and the database, cloud and
+ * task-IO modules behind it — into their import graph.
+ */
+function terminalOutputPathForHash(hash) {
+    return (0, path_1.join)(cache_directory_1.cacheDir, 'terminalOutputs', hash);
+}

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

@@ -221,7 +221,10 @@ function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode,
         validateOutputs(targetConfiguration.outputs);
         const result = new Set();
         for (const output of targetConfiguration.outputs) {
-            const interpolatedOutput = interpolate(output, {
+            // A leading `!` is negation, not part of the path: strip it so
+            // `{workspaceRoot}` still sits where interpolate requires it.
+            const isNegated = output.startsWith('!');
+            const interpolatedOutput = interpolate(isNegated ? output.substring(1) : output, {
                 projectRoot: node.data.root,
                 projectName: node.name,
                 project: { ...node.data, name: node.name }, // this is legacy
@@ -229,7 +232,7 @@ function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode,
             });
             if (!!interpolatedOutput &&
                 !interpolatedOutput.match(/{(projectRoot|workspaceRoot|(options.*))}/)) {
-                result.add(interpolatedOutput);
+                result.add(isNegated ? `!${interpolatedOutput}` : interpolatedOutput);
             }
         }
         return Array.from(result);

package/dist/src/utils/ab-testing.d.ts

@@ -1,4 +1,5 @@
 export declare const NX_CLOUD_URL = "https://nx.dev/nx-cloud";
+export declare const NX_CLOUD_DEMO_URL = "https://cloud.nx.app/demo/intro";
 /**
  * Clickable Nx Cloud marketing link for cloud prompt footers. The visible text
  * stays the clean `NX_CLOUD_URL` while clicks carry UTM attribution; terminals
@@ -7,6 +8,8 @@ export declare const NX_CLOUD_URL = "https://nx.dev/nx-cloud";
  * different commands.
  */
 export declare function nxCloudHyperlink(utmContent: string): string;
+/** Same as `nxCloudHyperlink`, pointing at the Nx Cloud demo (CLOUD-4640). */
+export declare function nxCloudDemoHyperlink(utmContent: string): string;
 /**
  * Meta payload types for recordStat telemetry (matches CNW format).
  */
@@ -25,7 +28,7 @@ export interface RecordStatMetaError {
     [key: string]: string | boolean;
 }
 export type RecordStatMeta = RecordStatMetaStart | RecordStatMetaComplete | RecordStatMetaError;
-export type MessageOptionKey = 'yes' | 'skip' | 'never';
+export type MessageOptionKey = 'yes' | 'skip';
 interface MessageData {
     code: string;
     message: string;

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.messages = exports.PromptMessages = exports.NX_CLOUD_URL = void 0;
+exports.messages = exports.PromptMessages = exports.NX_CLOUD_DEMO_URL = exports.NX_CLOUD_URL = void 0;
 exports.nxCloudHyperlink = nxCloudHyperlink;
+exports.nxCloudDemoHyperlink = nxCloudDemoHyperlink;
 exports.recordStat = recordStat;
-const tslib_1 = require("tslib");
 const node_child_process_1 = require("node:child_process");
 const is_ci_1 = require("./is-ci");
 const package_manager_1 = require("./package-manager");
 const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
 const terminal_link_1 = require("./terminal-link");
-const pc = tslib_1.__importStar(require("picocolors"));
 exports.NX_CLOUD_URL = 'https://nx.dev/nx-cloud';
+exports.NX_CLOUD_DEMO_URL = 'https://cloud.nx.app/demo/intro';
 /**
  * Clickable Nx Cloud marketing link for cloud prompt footers. The visible text
  * stays the clean `NX_CLOUD_URL` while clicks carry UTM attribution; terminals
@@ -19,8 +19,14 @@ exports.NX_CLOUD_URL = 'https://nx.dev/nx-cloud';
  * different commands.
  */
 function nxCloudHyperlink(utmContent) {
-    const tracked = `${exports.NX_CLOUD_URL}?utm_source=nx-cli&utm_medium=cli&utm_campaign=nx-cloud-connect&utm_content=${utmContent}`;
-    return (0, terminal_link_1.terminalLink)(exports.NX_CLOUD_URL, tracked);
+    return trackedHyperlink(exports.NX_CLOUD_URL, utmContent);
+}
+/** Same as `nxCloudHyperlink`, pointing at the Nx Cloud demo (CLOUD-4640). */
+function nxCloudDemoHyperlink(utmContent) {
+    return trackedHyperlink(exports.NX_CLOUD_DEMO_URL, utmContent);
+}
+function trackedHyperlink(url, utmContent) {
+    return (0, terminal_link_1.terminalLink)(url, `${url}?utm_source=nx-cli&utm_medium=cli&utm_campaign=nx-cloud-connect&utm_content=${utmContent}`);
 }
 const messageOptions = {
     setupNxCloud: [
@@ -31,7 +37,6 @@ const messageOptions = {
             choices: [
                 { value: 'yes', name: 'Yes' },
                 { value: 'skip', name: 'Skip for now' },
-                { value: 'never', name: pc.dim("No, don't ask again") },
             ],
             footer: '\nFree for small teams. Remote caching and task distribution. 2-minute setup:',
         },
@@ -42,7 +47,6 @@ const messageOptions = {
             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',
             hint: `\n(it's free and can be disabled any time)`,

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

@@ -1,10 +1,4 @@
-export declare function chunkify(target: string[], maxChunkLength?: number, 
-/**
- * How long each entry will be once it reaches the command line. Callers that
- * quote or escape afterwards pass that transformation's length here, so the
- * chunk is sized against what is actually spawned rather than the raw string.
- */
-measure?: (item: string) => number): string[][];
+export declare function chunkify(target: string[], maxChunkLength?: number): string[][];
 /**
  * Get the maximum length of a command-line argument string based on current platform
  *

package/dist/src/utils/chunkify.js

@@ -3,18 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.chunkify = chunkify;
 exports.getMaxArgLength = getMaxArgLength;
 const TERMINAL_SIZE = getMaxArgLength();
-function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500, 
-/**
- * How long each entry will be once it reaches the command line. Callers that
- * quote or escape afterwards pass that transformation's length here, so the
- * chunk is sized against what is actually spawned rather than the raw string.
- */
-measure = (item) => item.length) {
+function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500) {
     const chunks = [];
     let currentChunk = [];
     let currentChunkLength = 0;
     for (const file of target) {
-        const length = measure(file);
+        const length = file.length;
         if (
         // Prevent empty chunk if first file path is longer than maxChunkLength
         currentChunk.length &&

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

@@ -1,6 +1,7 @@
 import type { Arguments } from 'yargs';
 import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
+import type { OutputStyle } from '../command-line/yargs-utils/shared-options';
 export interface RawNxArgs extends NxArgs {
     prod?: boolean;
 }
@@ -28,6 +29,24 @@ export interface NxArgs {
     graph?: string | boolean;
     skipNxCache?: boolean;
     skipRemoteCache?: boolean;
+    /**
+     * The style the user named - CLI flag or `NX_DEFAULT_OUTPUT_STYLE`. Left
+     * undefined when they named none, and that absence is load-bearing: it is how
+     * the streaming and renderer-selection decisions tell "the user wants static"
+     * from "we defaulted to static", which stream continuous tasks differently.
+     */
+    specifiedOutputStyle?: OutputStyle;
+    /**
+     * What the run actually renders with, after the TUI, agent and failures-only
+     * defaults are applied. Always set. Every decision about what to PRINT reads
+     * this; every decision about what the user ASKED FOR reads the field above.
+     */
+    resolvedOutputStyle?: OutputStyle;
+    /**
+     * @deprecated Read `specifiedOutputStyle` for what the user named, or
+     * `resolvedOutputStyle` for what the run renders with. This will be removed
+     * in Nx 24.
+     */
     outputStyle?: string;
     tui?: boolean;
     nxBail?: boolean;