nx 22.7.0-beta.12 → 22.7.0-beta.13

package/dist/src/plugins/js/utils/register.js

@@ -8,6 +8,7 @@ exports.registerTranspiler = registerTranspiler;
 exports.registerTsConfigPaths = registerTsConfigPaths;
 exports.getTsNodeCompilerOptions = getTsNodeCompilerOptions;
 const path_1 = require("path");
+const fs_1 = require("fs");
 const logger_1 = require("../../../utils/logger");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const typescript_1 = require("./typescript");
@@ -49,6 +50,14 @@ const isInvokedByTsx = (() => {
     return (requireArgs.some((a) => isTsxPath(a)) ||
         importArgs.some((a) => isTsxPath(a)));
 })();
+/**
+ * Whether the current Node.js version supports native TypeScript execution
+ * via type stripping (Node 22.6+).
+ *
+ * process.features.typescript is 'strip' | 'transform' | false in Node 22.6+
+ */
+const nodeSupportsNativeTypescript = !!process.features
+    ?.typescript;
 /**
  * When process.features.typescript is truthy and the user has opted in via
  * NX_PREFER_NODE_STRIP_TYPES=true, we can skip registering swc-node or ts-node
@@ -63,8 +72,7 @@ const preferNodeStripTypes = (() => {
     if (process.env.NX_PREFER_NODE_STRIP_TYPES !== 'true') {
         return false;
     }
-    // process.features.typescript is 'strip' | 'transform' | false in Node 22.6+
-    return !!process.features?.typescript;
+    return nodeSupportsNativeTypescript;
 })();
 function registerTsProject(path, configFilename) {
     // See explanation alongside isInvokedByTsx declaration
@@ -257,7 +265,11 @@ function registerTranspiler(compilerOptions, tsConfigRaw) {
     // Function to register transpiler that returns cleanup function
     const transpiler = getTranspiler(compilerOptions, tsConfigRaw);
     if (!transpiler) {
-        warnNoTranspiler();
+        // If Node.js natively supports TypeScript (22.6+), no transpiler is needed.
+        // Don't warn — Node will handle .ts files via type stripping.
+        if (!nodeSupportsNativeTypescript) {
+            warnNoTranspiler();
+        }
         return () => { };
     }
     return transpiler();
@@ -279,7 +291,7 @@ function registerTsConfigPaths(tsConfigPath) {
          */
         if (tsConfigResult.resultType === 'success') {
             return tsconfigPaths.register({
-                baseUrl: tsConfigResult.absoluteBaseUrl,
+                baseUrl: resolvePathsBaseUrl(tsConfigPath),
                 paths: tsConfigResult.paths,
             });
         }
@@ -404,3 +416,70 @@ function getTsNodeCompilerOptions(compilerOptions) {
     }
     return result;
 }
+function resolvePathsBaseUrl(tsconfigPath) {
+    const chain = [];
+    const queue = [tsconfigPath];
+    while (queue.length > 0) {
+        const absolute = (0, path_1.resolve)(queue.shift());
+        const dir = (0, path_1.dirname)(absolute);
+        try {
+            const raw = JSON.parse((0, fs_1.readFileSync)(absolute, 'utf-8'));
+            chain.push({ dir, raw });
+            const exts = raw.extends
+                ? Array.isArray(raw.extends)
+                    ? raw.extends
+                    : [raw.extends]
+                : [];
+            for (const ext of exts) {
+                const resolved = resolveExtendsPath(ext, dir);
+                if (resolved) {
+                    queue.push(resolved);
+                }
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    let pathsIndex = -1;
+    for (let i = 0; i < chain.length; i++) {
+        if (chain[i].raw.compilerOptions?.paths &&
+            Object.keys(chain[i].raw.compilerOptions.paths).length > 0) {
+            pathsIndex = i;
+            break;
+        }
+    }
+    const searchStart = pathsIndex >= 0 ? pathsIndex : 0;
+    for (let i = searchStart; i < chain.length; i++) {
+        if (chain[i].raw.compilerOptions?.baseUrl) {
+            return (0, path_1.resolve)(chain[i].dir, chain[i].raw.compilerOptions.baseUrl);
+        }
+    }
+    return pathsIndex >= 0
+        ? chain[pathsIndex].dir
+        : (0, path_1.dirname)((0, path_1.resolve)(tsconfigPath));
+}
+function resolveExtendsPath(ext, fromDir) {
+    if (ext.startsWith('.') || (0, path_1.isAbsolute)(ext)) {
+        let resolved = (0, path_1.resolve)(fromDir, ext);
+        if ((0, fs_1.existsSync)(resolved))
+            return resolved;
+        if (!resolved.endsWith('.json')) {
+            resolved += '.json';
+            if ((0, fs_1.existsSync)(resolved))
+                return resolved;
+        }
+        return null;
+    }
+    try {
+        return require.resolve(ext, { paths: [fromDir] });
+    }
+    catch {
+        try {
+            return require.resolve(`${ext}/tsconfig.json`, { paths: [fromDir] });
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -254,19 +254,39 @@ function formatAggregateCreateNodesError(error, pluginName) {
         `${errorCount} occurred while processing files for the ${pluginName} plugin${pluginLocation}.`,
     ];
     const errorStackLines = [];
-    const innerErrors = error.errors;
-    for (const [file, e] of innerErrors) {
-        if (file) {
-            errorBodyLines.push(`  - ${file}: ${e.message}`);
-            errorStackLines.push(` - ${file}: ${e.stack}`);
+    // Group errors by file so repeated file paths aren't printed multiple times
+    const groupedErrors = new Map();
+    for (const [file, e] of error.errors) {
+        const key = file ?? null;
+        if (!groupedErrors.has(key)) {
+            groupedErrors.set(key, []);
         }
-        else {
-            errorBodyLines.push(`  - ${e.message}`);
-            errorStackLines.push(` - ${e.stack}`);
+        groupedErrors.get(key).push(e);
+    }
+    for (const [file, errors] of groupedErrors) {
+        if (file) {
+            errorBodyLines.push(`  - ${file}:`);
+            errorStackLines.push(` - ${file}:`);
         }
-        if (e.stack && process.env.NX_VERBOSE_LOGGING === 'true') {
-            const innerStackTrace = '    ' + e.stack.split('\n')?.join('\n    ');
-            errorStackLines.push(innerStackTrace);
+        for (const e of errors) {
+            const messageLines = e.message.split('\n');
+            const stackLines = e.stack.split('\n');
+            if (file) {
+                errorBodyLines.push(...messageLines.map((line) => `      ${line}`));
+                errorStackLines.push(...stackLines.map((line) => `     ${line}`));
+            }
+            else {
+                errorBodyLines.push(`  - ${messageLines[0]}`, ...messageLines.slice(1).map((line) => `    ${line}`));
+                errorStackLines.push(` - ${stackLines[0]}`, ...stackLines.slice(1).map((line) => `   ${line}`));
+            }
+            if (e.stack && process.env.NX_VERBOSE_LOGGING === 'true') {
+                const verboseIndent = file ? '       ' : '     ';
+                const innerStackTrace = e.stack
+                    .split('\n')
+                    .map((line) => `${verboseIndent}${line}`)
+                    .join('\n');
+                errorStackLines.push(innerStackTrace);
+            }
         }
     }
     error.stack = errorStackLines.join('\n');

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

@@ -55,6 +55,7 @@ export declare class IsolatedPlugin implements LoadedNxPlugin {
     private generateTxId;
     private sendRequest;
     private shutdownIfInactive;
+    setWorkerEnv(env: Record<string, string>): Promise<void>;
     notifyPhaseAborted(phase: Phase, lastCompletedHook: Hook): void;
     shutdown(): void;
     private registerProcessMetrics;

package/dist/src/project-graph/plugins/isolation/isolated-plugin.js

@@ -272,6 +272,15 @@ class IsolatedPlugin {
         logger_1.logger.verbose(`[isolated-plugin] shutting down worker for "${this.name}" after ${hookName}`);
         this.shutdown();
     }
+    async setWorkerEnv(env) {
+        if (!this._alive) {
+            return;
+        }
+        const result = await this.sendRequest('setWorkerEnv', env);
+        if (result.success === false) {
+            throw result.error;
+        }
+    }
     notifyPhaseAborted(phase, lastCompletedHook) {
         if (this.lifecycle?.notifyPhaseAborted(phase, lastCompletedHook)) {
             this.shutdownIfInactive(lastCompletedHook);

package/dist/src/project-graph/plugins/isolation/message-types.d.ts

@@ -55,5 +55,5 @@ export type AllResults<TDefs extends MessageDefs> = {
 export type Handlers<TDefs extends MessageDefs> = {
     [K in keyof TDefs & string]: (payload: TDefs[K]['payload']) => TDefs[K] extends {
         result: unknown;
-    } ? MaybePromise<TDefs[K]['result'] | void> : MaybePromise<void>;
+    } ? MaybePromise<TDefs[K]['result']> : MaybePromise<void>;
 };

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

@@ -97,6 +97,15 @@ type PluginMessageDefs = DefineMessages<{
             error: Error;
         };
     };
+    setWorkerEnv: {
+        payload: Record<string, string>;
+        result: {
+            success: true;
+        } | {
+            success: false;
+            error: Error;
+        };
+    };
 }>;
 /** Union of all plugin worker message types */
 export type PluginWorkerMessage = AllMessages<PluginMessageDefs>;

package/dist/src/project-graph/plugins/isolation/messaging.js

@@ -15,6 +15,7 @@ const MESSAGE_TYPES = [
     'createMetadata',
     'preTasksExecution',
     'postTasksExecution',
+    'setWorkerEnv',
 ];
 const RESULT_TYPES = [
     'loadResult',
@@ -23,6 +24,7 @@ const RESULT_TYPES = [
     'createMetadataResult',
     'preTasksExecutionResult',
     'postTasksExecutionResult',
+    'setWorkerEnvResult',
 ];
 function isPluginWorkerMessage(message) {
     return (typeof message === 'object' &&

package/dist/src/project-graph/plugins/isolation/plugin-worker.js

@@ -8,8 +8,8 @@ const serializable_error_1 = require("../../../utils/serializable-error");
 const messaging_1 = require("./messaging");
 const fs_1 = require("fs");
 const net_1 = require("net");
-require("../../../utils/perf-logging");
 const analytics_1 = require("../../../analytics");
+require("../../../utils/perf-logging");
 const environment = process.env;
 (0, analytics_1.startAnalytics)();
 node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- end`);
@@ -41,7 +41,7 @@ const server = (0, net_1.createServer)((socket) => {
             load: async ({ plugin: pluginConfiguration, root, name, pluginPath, shouldRegisterTSTranspiler, }) => {
                 loadErrorTimeout?.clear();
                 process.chdir(root);
-                try {
+                return withErrorHandling(async () => {
                     const { loadResolvedNxPluginAsync } = await Promise.resolve(require(require.resolve('../load-resolved-plugin')));
                     // Register the ts-transpiler if we are pointing to a
                     // plain ts file that's not part of a plugin project
@@ -62,74 +62,30 @@ const server = (0, net_1.createServer)((socket) => {
                         hasPostTasksExecution: 'postTasksExecution' in plugin && !!plugin.postTasksExecution,
                         success: true,
                     };
-                }
-                catch (e) {
-                    return {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                    };
-                }
-            },
-            createNodes: async function createNodes({ configFiles, context }) {
-                try {
-                    const result = await plugin.createNodes[1](configFiles, context);
-                    return { result, success: true };
-                }
-                catch (e) {
-                    return {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                    };
-                }
-            },
-            createDependencies: async function createDependencies({ context }) {
-                try {
-                    const result = await plugin.createDependencies(context);
-                    return { dependencies: result, success: true };
-                }
-                catch (e) {
-                    return {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                    };
-                }
-            },
-            createMetadata: async function createMetadata({ graph, context }) {
-                try {
-                    const result = await plugin.createMetadata(graph, context);
-                    return { metadata: result, success: true };
-                }
-                catch (e) {
-                    return {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                    };
-                }
-            },
-            preTasksExecution: async ({ context }) => {
-                try {
-                    const mutations = await plugin.preTasksExecution?.(context);
-                    return { success: true, mutations };
-                }
-                catch (e) {
-                    return {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                    };
-                }
+                });
             },
-            postTasksExecution: async ({ context }) => {
-                try {
-                    await plugin.postTasksExecution?.(context);
-                    return { success: true };
+            createNodes: async ({ configFiles, context }) => withErrorHandling(async () => {
+                const result = await plugin.createNodes[1](configFiles, context);
+                return { result, success: true };
+            }),
+            createDependencies: async ({ context }) => withErrorHandling(async () => {
+                const result = await plugin.createDependencies(context);
+                return { dependencies: result, success: true };
+            }),
+            createMetadata: async ({ graph, context }) => withErrorHandling(async () => {
+                const result = await plugin.createMetadata(graph, context);
+                return { metadata: result, success: true };
+            }),
+            preTasksExecution: async ({ context }) => withErrorHandling(async () => {
+                const mutations = await plugin.preTasksExecution?.(context);
+                return { success: true, mutations };
+            }),
+            postTasksExecution: async ({ context }) => withErrorHandling(() => plugin.postTasksExecution?.(context)),
+            setWorkerEnv: (env) => withErrorHandling(() => {
+                for (const envKey in env) {
+                    process.env[envKey] = env[envKey];
                 }
-                catch (e) {
-                    return {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                    };
-                }
-            },
+            }),
         });
     }));
     // When the host disconnects, clean up and exit.
@@ -144,6 +100,18 @@ const server = (0, net_1.createServer)((socket) => {
 });
 server.listen(socketPath);
 logger_1.logger.verbose(`[plugin-worker] "${expectedPluginName}" (pid: ${process.pid}) listening on ${socketPath}`);
+async function withErrorHandling(cb) {
+    try {
+        const result = await cb();
+        return result ?? { success: true };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: (0, serializable_error_1.createSerializableError)(e),
+        };
+    }
+}
 function setErrorTimeout(timeoutMs, errorMessage) {
     if (environment.NX_PLUGIN_NO_TIMEOUTS === 'true') {
         return;

package/dist/src/project-graph/plugins/loaded-nx-plugin.d.ts

@@ -31,5 +31,11 @@ export declare class LoadedNxPlugin {
      *   abort (e.g. 'createNodes').
      */
     notifyPhaseAborted?(phase: string, lastCompletedHook: string): void;
+    /**
+     * Forwards updated environment variables to the plugin worker process.
+     * Only meaningful for isolated plugins; in-process plugins share the
+     * daemon's process.env automatically.
+     */
+    setWorkerEnv?(env: Record<string, string>): Promise<void>;
     constructor(plugin: NxPluginV2, pluginDefinition: PluginConfiguration, index?: number);
 }

package/dist/src/tasks-runner/cache.d.ts

@@ -26,6 +26,9 @@ export declare class DbCache {
     });
     init(): Promise<void>;
     get(task: Task): Promise<CachedResult | null>;
+    getBatch(tasks: Task[]): Promise<Map<string, CachedResult & {
+        remote: boolean;
+    }>>;
     getUsedCacheSpace(): number;
     private applyRemoteCacheResults;
     put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
@@ -54,6 +57,9 @@ export declare class Cache {
     constructor(options: DefaultTasksRunnerOptions);
     removeOldCacheRecords(): void;
     get(task: Task): Promise<CachedResult | null>;
+    getBatch(tasks: Task[]): Promise<Map<string, CachedResult & {
+        remote: boolean;
+    }>>;
     put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
     copyFilesFromCache(hash: string, cachedResult: CachedResult, outputs: string[]): Promise<void>;
     temporaryOutputPath(task: Task): string;

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

@@ -97,6 +97,54 @@ class DbCache {
             return null;
         }
     }
+    async getBatch(tasks) {
+        const results = new Map();
+        if (tasks.length === 0)
+            return results;
+        // Single-task fast path: direct primary-key lookup beats rarray
+        // vtable overhead when there's nothing to amortize over.
+        if (tasks.length === 1) {
+            const res = await this.get(tasks[0]);
+            if (res)
+                results.set(tasks[0].hash, res);
+            return results;
+        }
+        const hashes = tasks.map((t) => t.hash);
+        // 1. Local: one rarray SQL query + parallel terminal output reads.
+        //    batchResults is index-aligned with tasks, so we walk in lockstep.
+        const batchResults = this.cache.getBatch(hashes);
+        const remoteMisses = [];
+        for (const [i, task] of tasks.entries()) {
+            const res = batchResults[i];
+            if (res) {
+                results.set(task.hash, {
+                    ...res,
+                    terminalOutput: res.terminalOutput ?? '',
+                    remote: false,
+                });
+            }
+            else if (this.remoteCache) {
+                remoteMisses.push(task);
+            }
+        }
+        // 2. Remote: parallel HTTP retrievals for anything the local SQL missed.
+        //    The RemoteCache interface has no batch endpoint, so this is just
+        //    Promise.all over individual retrieve() calls.
+        if (remoteMisses.length > 0) {
+            await Promise.all(remoteMisses.map(async (task) => {
+                const res = await this.remoteCache.retrieve(task.hash, this.cache.cacheDirectory);
+                if (res) {
+                    this.applyRemoteCacheResults(task.hash, res, task.outputs);
+                    results.set(task.hash, {
+                        ...res,
+                        terminalOutput: res.terminalOutput ?? '',
+                        remote: true,
+                    });
+                }
+            }));
+        }
+        return results;
+    }
     getUsedCacheSpace() {
         return this.cache.getCacheSize();
     }
@@ -304,6 +352,16 @@ class Cache {
             return null;
         }
     }
+    async getBatch(tasks) {
+        // Legacy file-based cache has no native batch support — loop in parallel.
+        const results = new Map();
+        const entries = await Promise.all(tasks.map(async (t) => ({ task: t, res: await this.get(t) })));
+        for (const { task, res } of entries) {
+            if (res)
+                results.set(task.hash, res);
+        }
+        return results;
+    }
     async put(task, terminalOutput, outputs, code) {
         return tryAndRetry(async () => {
             /**

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

@@ -114,7 +114,7 @@ async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson
     const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
     let groupId = 0;
     let nextBatch = orchestrator.nextBatch();
-    let batchResults = [];
+    const batchResults = [];
     /**
      * Set of task ids that were part of batches
      */
@@ -126,12 +126,18 @@ async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson
         batchResults.push(orchestrator.applyFromCacheOrRunBatch(true, nextBatch, groupId++));
         nextBatch = orchestrator.nextBatch();
     }
-    const taskResults = tasks
-        // Filter out tasks which were not part of batches
-        .filter((task) => !batchTasks.has(task.id))
-        .map((task) => orchestrator
-        .applyFromCacheOrRunTask(true, task, groupId++)
-        .then((r) => [r]));
+    const discreteTasks = tasks.filter((task) => !batchTasks.has(task.id));
+    // Bulk-resolve every discrete task's cache state in one shot —
+    // single SQL call plus parallel remote retrievals. Batches kicked
+    // off above continue running concurrently while we await this.
+    const cacheHits = await orchestrator.resolveCachedTasks(true, discreteTasks, groupId++);
+    const cacheHitsById = new Map(cacheHits.map((h) => [h.task.id, h]));
+    const taskResults = discreteTasks.map(async (task) => {
+        const hit = cacheHitsById.get(task.id);
+        if (hit)
+            return [hit];
+        return [await orchestrator.runTaskDirectly(true, task, groupId++)];
+    });
     return [...batchResults, ...taskResults];
 }
 async function runContinuousTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {

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

@@ -674,7 +674,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                 }
                 return hasher.hashTask(task, taskGraph_, env);
             },
-            hashTasks(task, taskGraph_, env) {
+            hashTasks(tasks, taskGraph_, envOrPerTaskEnvs) {
                 if (!taskGraph_) {
                     output_1.output.warn({
                         title: `TaskGraph is now required as an argument to hashTasks`,
@@ -685,7 +685,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                     });
                     taskGraph_ = taskGraph;
                 }
-                if (!env) {
+                if (!envOrPerTaskEnvs) {
                     output_1.output.warn({
                         title: `The environment variables are now required as an argument to hashTasks`,
                         bodyLines: [
@@ -693,9 +693,11 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                             'This will result in an error in Nx 20',
                         ],
                     });
-                    env = process.env;
+                    envOrPerTaskEnvs = process.env;
                 }
-                return hasher.hashTasks(task, taskGraph_, env);
+                // hasher.hashTasks accepts either legacy single-env or the new
+                // per-task-env shape and normalizes internally.
+                return hasher.hashTasks(tasks, taskGraph_, envOrPerTaskEnvs);
             },
         },
         daemon: client_1.daemonClient,
@@ -816,7 +818,13 @@ function getTasksRunnerPath(runner, nxJson) {
         process.env.NX_CLOUD_ACCESS_TOKEN ||
         // Nx Cloud ID specified in nxJson
         nxJson.nxCloudId;
-    return isCloudRunner ? 'nx-cloud' : defaultTasksRunnerPath;
+    // NX_NO_CLOUD / neverConnectToCloud wins over any ambient token — otherwise
+    // a surrounding CI env variable would still route through the cloud shell,
+    // which resolves the default tasks runner via its own require bridge and
+    // can pull in a different Nx version than the workspace's own.
+    return isCloudRunner && !(0, nx_cloud_utils_1.isNxCloudDisabled)(nxJson)
+        ? 'nx-cloud'
+        : defaultTasksRunnerPath;
 }
 function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
     const defaultCacheableOperations = [];

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

@@ -19,13 +19,29 @@ function getEnvVariablesForBatchProcess(skipNxCache, captureStderr) {
         ...getNxEnvVariablesForForkedProcess(process.env.FORCE_COLOR === undefined ? 'true' : process.env.FORCE_COLOR, skipNxCache, captureStderr),
     };
 }
+// The orchestrator now calls this eagerly during the coordinator pre-hash
+// in addition to processTask (and again in hashBatchTasks), so the same
+// task hits this function multiple times per run. Each call reads 3+ .env
+// files from disk — memoize by task.id to skip the repeat work.
+//
+// Cache lifetime is the current Nx invocation: the function is only called
+// from CLI/orchestrator code (not the long-lived daemon), so the map is
+// scoped to a single run. Callers must not mutate the returned env — they
+// already spread it into new objects before adding task-specific overrides
+// (see getEnvVariablesForTask).
+const taskSpecificEnvCache = new Map();
 function getTaskSpecificEnv(task, graph) {
+    const cached = taskSpecificEnvCache.get(task.id);
+    if (cached)
+        return cached;
     // Unload any dot env files at the root of the workspace that were loaded on init of Nx.
     const taskEnv = unloadDotEnvFiles({ ...process.env });
-    return process.env.NX_LOAD_DOT_ENV_FILES === 'true'
+    const env = process.env.NX_LOAD_DOT_ENV_FILES === 'true'
         ? loadDotEnvFilesForTask(task, graph, taskEnv)
         : // If not loading dot env files, ensure env vars created by system are still loaded
             taskEnv;
+    taskSpecificEnvCache.set(task.id, env);
+    return env;
 }
 function getEnvVariablesForTask(task, taskSpecificEnv, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
     const res = {