nx 23.1.0 → 23.2.0-beta.0

package/dist/src/plugins/js/lock-file/npm-parser.js

@@ -133,6 +133,22 @@ function findV3Version(snapshot, packageName) {
 }
 function getDependencies(data, keyMap, ctx) {
     const dependencies = [];
+    // Memoizes semver `satisfies(version, range)` for this dependency walk. The
+    // same (version, range) pairs recur across many edges, so the range parse
+    // happens once per distinct pair instead of once per edge. Scoped to the walk
+    // (not module-global) so V8 collects it when dependency creation finishes
+    // rather than retaining it for the daemon's lifetime.
+    const versionSatisfiesCache = new Map();
+    const cachedSatisfies = (version, range) => {
+        const key = `${version}\n${range}`;
+        const cached = versionSatisfiesCache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const result = (0, semver_1.satisfies)(version, range);
+        versionSatisfiesCache.set(key, result);
+        return result;
+    };
     if (data.lockfileVersion > 1) {
         Object.entries(data.packages).forEach(([path, snapshot]) => {
             // we are skipping workspaces packages
@@ -147,7 +163,7 @@ function getDependencies(data, keyMap, ctx) {
             ].forEach((section) => {
                 if (section) {
                     Object.entries(section).forEach(([name, versionRange]) => {
-                        const target = findTarget(path, keyMap, name, versionRange);
+                        const target = findTarget(path, keyMap, name, versionRange, cachedSatisfies);
                         if (target) {
                             const dep = {
                                 source: sourceName,
@@ -164,12 +180,12 @@ function getDependencies(data, keyMap, ctx) {
     }
     else {
         Object.entries(data.dependencies).forEach(([packageName, snapshot]) => {
-            addV1NodeDependencies(`node_modules/${packageName}`, snapshot, dependencies, keyMap, ctx);
+            addV1NodeDependencies(`node_modules/${packageName}`, snapshot, dependencies, keyMap, ctx, cachedSatisfies);
         });
     }
     return dependencies;
 }
-function findTarget(sourcePath, keyMap, targetName, versionRange, 
+function findTarget(sourcePath, keyMap, targetName, versionRange, cachedSatisfies, 
 // When a package is found at a path but its version doesn't satisfy the
 // range (e.g. due to npm overrides), we keep it as a fallback. npm already
 // resolved this dependency to that location, so it is the correct target
@@ -186,12 +202,13 @@ fallback) {
             versionRange.startsWith('npm:')) {
             const nodeVersion = child.data.version.slice(child.data.version.indexOf('@', 5) + 1);
             const depVersion = versionRange.slice(versionRange.indexOf('@', 5) + 1);
-            if (nodeVersion === depVersion || (0, semver_1.satisfies)(nodeVersion, depVersion)) {
+            if (nodeVersion === depVersion ||
+                cachedSatisfies(nodeVersion, depVersion)) {
                 return child;
             }
         }
         else if (child.data.version === versionRange ||
-            (0, semver_1.satisfies)(child.data.version, versionRange)) {
+            cachedSatisfies(child.data.version, versionRange)) {
             return child;
         }
         // Version mismatch — save as fallback (could be an npm override)
@@ -203,13 +220,17 @@ fallback) {
     if (!sourcePath) {
         return fallback;
     }
-    return findTarget(sourcePath.split('node_modules/').slice(0, -1).join('node_modules/'), keyMap, targetName, versionRange, fallback);
+    // Walk one level up the nesting chain by dropping the trailing
+    // `node_modules/<pkg>` segment. Slash-index arithmetic avoids the
+    // split/slice/join array allocation on every hop.
+    const lastNodeModules = sourcePath.lastIndexOf('node_modules/');
+    return findTarget(lastNodeModules === -1 ? '' : sourcePath.substring(0, lastNodeModules), keyMap, targetName, versionRange, cachedSatisfies, fallback);
 }
-function addV1NodeDependencies(path, snapshot, dependencies, keyMap, ctx) {
+function addV1NodeDependencies(path, snapshot, dependencies, keyMap, ctx, cachedSatisfies) {
     if (keyMap.has(path) && snapshot.requires) {
         const source = keyMap.get(path).name;
         Object.entries(snapshot.requires).forEach(([name, versionRange]) => {
-            const target = findTarget(path, keyMap, name, versionRange);
+            const target = findTarget(path, keyMap, name, versionRange, cachedSatisfies);
             if (target) {
                 const dep = {
                     source: source,
@@ -223,14 +244,14 @@ function addV1NodeDependencies(path, snapshot, dependencies, keyMap, ctx) {
     }
     if (snapshot.dependencies) {
         Object.entries(snapshot.dependencies).forEach(([depName, depSnapshot]) => {
-            addV1NodeDependencies(`${path}/node_modules/${depName}`, depSnapshot, dependencies, keyMap, ctx);
+            addV1NodeDependencies(`${path}/node_modules/${depName}`, depSnapshot, dependencies, keyMap, ctx, cachedSatisfies);
         });
     }
     const { peerDependencies } = getPeerDependencies(path);
     if (peerDependencies) {
         const node = keyMap.get(path);
         Object.entries(peerDependencies).forEach(([depName, depSpec]) => {
-            const target = findTarget(path, keyMap, depName, depSpec);
+            const target = findTarget(path, keyMap, depName, depSpec, cachedSatisfies);
             if (target) {
                 const dep = {
                     source: node.name,
@@ -358,10 +379,11 @@ function mapSnapshots(rootLockFile, graph) {
     const nestedNodes = new Set();
     const visitedNodes = new Map();
     const remappedPackages = new Map();
+    const packageIndex = buildV3Index(rootLockFile.packages);
     // add first level children
     Object.values(graph.externalNodes).forEach((node) => {
         if (node.name === `npm:${node.data.packageName}`) {
-            const mappedPackage = mapPackage(rootLockFile, node.data.packageName, node.data.version);
+            const mappedPackage = mapPackage(rootLockFile, packageIndex, node.data.packageName, node.data.version);
             remappedPackages.set(mappedPackage.path, mappedPackage);
             visitedNodes.set(node, {
                 packagePaths: new Set([mappedPackage.path]),
@@ -375,7 +397,7 @@ function mapSnapshots(rootLockFile, graph) {
     let remappedPackagesArray;
     if (nestedNodes.size) {
         const invertedGraph = (0, operators_1.reverse)(graph);
-        nestMappedPackages(invertedGraph, remappedPackages, nestedNodes, visitedNodes, rootLockFile);
+        nestMappedPackages(invertedGraph, remappedPackages, nestedNodes, visitedNodes, rootLockFile, packageIndex);
         // initially we naively map package paths to topParent/../parent/child
         // but some of those should be nested higher up the tree
         remappedPackagesArray = elevateNestedPaths(remappedPackages);
@@ -385,14 +407,14 @@ function mapSnapshots(rootLockFile, graph) {
     }
     return remappedPackagesArray.sort((a, b) => a.path.localeCompare(b.path));
 }
-function mapPackage(rootLockFile, packageName, version, parentPath = '') {
+function mapPackage(rootLockFile, packageIndex, packageName, version, parentPath = '') {
     const lockfileVersion = rootLockFile.lockfileVersion;
     let valueV3, valueV1;
     if (lockfileVersion < 3) {
         valueV1 = findMatchingPackageV1(rootLockFile.dependencies, packageName, version);
     }
     if (lockfileVersion > 1) {
-        valueV3 = findMatchingPackageV3(rootLockFile.packages, packageName, version);
+        valueV3 = findMatchingPackageV3(packageIndex, packageName, version);
     }
     return {
         path: parentPath + `node_modules/${packageName}`,
@@ -401,7 +423,7 @@ function mapPackage(rootLockFile, packageName, version, parentPath = '') {
         valueV3,
     };
 }
-function nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, rootLockFile) {
+function nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, rootLockFile, packageIndex) {
     const initialSize = nestedNodes.size;
     if (!initialSize) {
         return;
@@ -421,7 +443,7 @@ function nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, ro
             if (visitedNodes.has(targetNode) &&
                 !visitedNodes.get(targetNode).unresolvedParents.size) {
                 visitedNodes.get(targetNode).packagePaths.forEach((path) => {
-                    const mappedPackage = mapPackage(rootLockFile, node.data.packageName, node.data.version, path + '/');
+                    const mappedPackage = mapPackage(rootLockFile, packageIndex, node.data.packageName, node.data.version, path + '/');
                     result.set(mappedPackage.path, mappedPackage);
                     visitedNodes.get(node).packagePaths.add(mappedPackage.path);
                     visitedNodes.get(node).unresolvedParents.delete(target);
@@ -439,7 +461,7 @@ function nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, ro
         ].join('\n'));
     }
     else {
-        nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, rootLockFile);
+        nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, rootLockFile, packageIndex);
     }
 }
 // sort paths by number of segments and then alphabetically
@@ -495,16 +517,38 @@ function elevateNestedPaths(remappedPackages) {
     });
     return Array.from(result.values());
 }
-function findMatchingPackageV3(packages, name, version) {
-    for (const [key, { dev, peer, ...snapshot }] of Object.entries(packages)) {
-        if (key.endsWith(`node_modules/${name}`)) {
-            if ([
-                snapshot.version,
-                snapshot.resolved,
-                `npm:${snapshot.name}@${snapshot.version}`,
-            ].includes(version)) {
-                return snapshot;
-            }
+// Bucket packages by their trailing "node_modules/<name>" segment so a lookup
+// scans only that name's copies instead of every package (was O(nodes *
+// allPackages)). Mirrors the old `key.endsWith(node_modules/<name>)` match:
+// the name is whatever follows the last "node_modules/" in the key.
+function buildV3Index(packages) {
+    const index = new Map();
+    if (!packages)
+        return index;
+    const marker = 'node_modules/';
+    for (const key of Object.keys(packages)) {
+        const i = key.lastIndexOf(marker);
+        if (i === -1)
+            continue; // root "" / workspace paths never matched endsWith
+        const name = key.slice(i + marker.length);
+        let bucket = index.get(name);
+        if (!bucket)
+            index.set(name, (bucket = []));
+        bucket.push(packages[key]);
+    }
+    return index;
+}
+function findMatchingPackageV3(packageIndex, name, version) {
+    const bucket = packageIndex.get(name);
+    if (!bucket)
+        return undefined;
+    for (const { dev, peer, ...snapshot } of bucket) {
+        if ([
+            snapshot.version,
+            snapshot.resolved,
+            `npm:${snapshot.name}@${snapshot.version}`,
+        ].includes(version)) {
+            return snapshot;
         }
     }
 }

package/dist/src/plugins/js/lock-file/pnpm-parser.js

@@ -142,7 +142,12 @@ function getNodes(data, isV5) {
     if (data.patchedDependencies) {
         for (const specifier of Object.keys(data.patchedDependencies)) {
             const patchInfo = data.patchedDependencies[specifier];
-            if (patchInfo && typeof patchInfo === 'object' && 'hash' in patchInfo) {
+            const patchHash = typeof patchInfo === 'string'
+                ? patchInfo
+                : patchInfo && typeof patchInfo === 'object' && 'hash' in patchInfo
+                    ? patchInfo.hash
+                    : undefined;
+            if (patchHash) {
                 const packageName = extractNameFromKey(specifier, false);
                 const versionSpecifier = getVersion(specifier, packageName) || null;
                 if (!patchEntriesByPackage.has(packageName)) {
@@ -150,7 +155,7 @@ function getNodes(data, isV5) {
                 }
                 patchEntriesByPackage.get(packageName).push({
                     versionSpecifier,
-                    hash: patchInfo.hash,
+                    hash: patchHash,
                 });
             }
         }
@@ -391,9 +396,12 @@ function parseBaseVersion(rawVersion, isV5) {
 }
 function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson, workspaceRoot) {
     const data = (0, pnpm_normalizer_1.parseAndNormalizePnpmLockfile)(rootLockFileContent);
-    const { lockfileVersion, packages, importers } = data;
-    const { snapshot: rootSnapshot, importers: requiredImporters } = mapRootSnapshot(packageJson, importers, packages, graph, +lockfileVersion, workspaceRoot);
-    const snapshots = mapSnapshots(data.packages, graph.externalNodes, +lockfileVersion);
+    const { lockfileVersion, importers } = data;
+    // pnpm omits the packages block for workspace-only lockfiles (no external deps)
+    const packages = data.packages ?? {};
+    const packageIndex = indexPackagesByName(packages, +lockfileVersion);
+    const { snapshot: rootSnapshot, importers: requiredImporters } = mapRootSnapshot(packageJson, importers, packages, packageIndex, graph, +lockfileVersion, workspaceRoot);
+    const snapshots = mapSnapshots(packages, packageIndex, graph.externalNodes, +lockfileVersion);
     const workspaceModules = (0, get_workspace_packages_from_graph_1.getWorkspacePackagesFromGraph)(graph);
     // Walk transitive workspace deps so every package copy-workspace-modules
     // writes to disk has a matching importer block. Without this, pnpm errors
@@ -455,12 +463,10 @@ function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson, workspac
     };
     return (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output);
 }
-function mapSnapshots(packages, nodes, lockfileVersion) {
+function mapSnapshots(packages, packageIndex, nodes, lockfileVersion) {
     const result = {};
     Object.values(nodes).forEach((node) => {
-        const matchedKeys = findOriginalKeys(packages, node, lockfileVersion, {
-            returnFullKey: true,
-        });
+        const matchedKeys = findOriginalKeys(packages, packageIndex, node, lockfileVersion, { returnFullKey: true });
         // the package manager doesn't check for types of dependencies
         // so we can safely set all to prod
         matchedKeys.forEach(([key, snapshot]) => {
@@ -500,10 +506,35 @@ function remapDependencies(snapshot) {
         }
     });
 }
-function findOriginalKeys(packages, { data: { packageName, version } }, lockfileVersion, { returnFullKey } = {}) {
-    const matchedKeys = [];
+// Bucket package keys by their package name so a node only scans its own name's
+// versions instead of every key (was O(nodes * allPackages)). v5 is excluded
+// below and keeps the full scan: its standard keys use a "/" separator while
+// tarball keys use "@", so a single name index would misfile v5 tarballs.
+function indexPackagesByName(packages, lockfileVersion) {
+    const isV5 = lockfileVersion < 6;
+    const index = new Map();
     for (const key of Object.keys(packages)) {
-        const snapshot = packages[key];
+        const name = extractNameFromKey(key, isV5);
+        let bucket = index.get(name);
+        if (!bucket)
+            index.set(name, (bucket = []));
+        bucket.push([key, packages[key]]);
+    }
+    return index;
+}
+// npm alias version is "npm:<name>@<ver>"; extract <name> the same way
+// versionIsAlias does so the index lookup matches the alias branch below.
+function aliasTargetName(version) {
+    return version.slice('npm:'.length, version.indexOf('@', 'npm:'.length + 1));
+}
+const NO_CANDIDATES = [];
+function findOriginalKeys(packages, packageIndex, node, lockfileVersion, { returnFullKey } = {}) {
+    const { data: { packageName, version }, } = node;
+    const candidates = lockfileVersion >= 6
+        ? (packageIndex.get(version.startsWith('npm:') ? aliasTargetName(version) : packageName) ?? NO_CANDIDATES)
+        : Object.entries(packages);
+    const matchedKeys = [];
+    for (const [key, snapshot] of candidates) {
         // tarball package
         if (key.startsWith(`${packageName}@${version}`) &&
             snapshot.resolution?.['tarball']) {
@@ -562,10 +593,11 @@ function versionIsAlias(key, versionExpr, lockfileVersion) {
         ? key.startsWith(`${packageName}/${version}`)
         : key.startsWith(`${packageName}@${version}`);
 }
-function mapRootSnapshot(packageJson, rootImporters, packages, graph, lockfileVersion, workspaceRoot) {
+function mapRootSnapshot(packageJson, rootImporters, packages, packageIndex, graph, lockfileVersion, workspaceRoot) {
     const workspaceModules = (0, get_workspace_packages_from_graph_1.getWorkspacePackagesFromGraph)(graph);
     const snapshot = { specifiers: {} };
     const importers = {};
+    const manager = (0, catalog_1.getCatalogManager)(workspaceRoot);
     [
         'dependencies',
         'optionalDependencies',
@@ -575,7 +607,6 @@ function mapRootSnapshot(packageJson, rootImporters, packages, graph, lockfileVe
         if (packageJson[depType]) {
             Object.keys(packageJson[depType]).forEach((packageName) => {
                 let version = packageJson[depType][packageName];
-                const manager = (0, catalog_1.getCatalogManager)(workspaceRoot);
                 if (manager?.isCatalogReference(version)) {
                     version = manager.resolveCatalogReference(workspaceRoot, packageName, version);
                     if (!version) {
@@ -612,7 +643,7 @@ function mapRootSnapshot(packageJson, rootImporters, packages, graph, lockfileVe
                     // peer dependencies are mapped to dependencies
                     let section = depType === 'peerDependencies' ? 'dependencies' : depType;
                     snapshot[section] = snapshot[section] || {};
-                    snapshot[section][packageName] = findOriginalKeys(packages, node, lockfileVersion)[0][0];
+                    snapshot[section][packageName] = findOriginalKeys(packages, packageIndex, node, lockfileVersion)[0][0];
                 }
             });
         }

package/dist/src/plugins/js/lock-file/project-graph-pruning.js

@@ -38,9 +38,9 @@ function normalizeDependencies(packageJson, graph, workspacePackages, workspaceR
         ...optionalDependencies,
         ...peerDependencies,
     };
+    const manager = (0, catalog_1.getCatalogManager)(workspaceRootPath);
     Object.entries(combinedDependencies).forEach(([packageName, versionRange]) => {
         let resolvedVersionRange = versionRange;
-        const manager = (0, catalog_1.getCatalogManager)(workspaceRootPath);
         if (manager?.isCatalogReference(versionRange)) {
             resolvedVersionRange = manager.resolveCatalogReference(workspaceRootPath, packageName, versionRange);
             if (!resolvedVersionRange) {

package/dist/src/plugins/js/lock-file/yarn-parser.js

@@ -314,9 +314,10 @@ function mapSnapshots(rootDependencies, nodes, packageJson, workspaceModules, is
     };
     // yarn classic splits keys when parsing so we need to stich them back together
     const groupedDependencies = groupDependencies(rootDependencies, isBerry);
+    const keyIndex = buildYarnKeyIndex(groupedDependencies);
     // collect snapshots and their matching keys
     Object.values(nodes).forEach((node) => {
-        const foundOriginalKeys = findOriginalKeys(groupedDependencies, node, workspaceModules);
+        const foundOriginalKeys = findOriginalKeys(groupedDependencies, keyIndex, node, workspaceModules);
         if (!foundOriginalKeys) {
             throw new Error(`Original key(s) not found for "${node.data.packageName}@${node.data.version}" while pruning yarn.lock.`);
         }
@@ -349,7 +350,7 @@ function mapSnapshots(rootDependencies, nodes, packageJson, workspaceModules, is
         }
         if (isBerry) {
             // look for patched versions
-            const patch = findPatchedKeys(groupedDependencies, node, resolutions[node.data.packageName]);
+            const patch = findPatchedKeys(groupedDependencies, keyIndex, node, resolutions[node.data.packageName]);
             if (patch) {
                 const [matchedKeys, snapshot] = patch;
                 snapshotMap.set(snapshot, new Set(matchedKeys));
@@ -424,8 +425,34 @@ function isClassicAlias(node, keys) {
     return (node.data.version.startsWith('npm:') &&
         keys.some((k) => k === `${node.data.packageName}@${node.data.version}`));
 }
-function findOriginalKeys(dependencies, node, workspaceModules) {
+// Bucket grouped-dependency key expressions by the package names they contain
+// so a node scans only its own name's entries (was O(nodes * allEntries)). A
+// key like "foo@npm:1.0" indexes under "foo"; the inner match checks below are
+// unchanged, so candidates are exactly the entries the old full scan would not
+// have skipped and the result is identical.
+function extractYarnKeyName(key) {
+    const at = key.indexOf('@', 1);
+    return at === -1 ? key : key.slice(0, at);
+}
+function buildYarnKeyIndex(dependencies) {
+    const index = new Map();
     for (const keyExpr of Object.keys(dependencies)) {
+        const seen = new Set();
+        for (const k of keyExpr.split(', ')) {
+            const name = extractYarnKeyName(k);
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            let bucket = index.get(name);
+            if (!bucket)
+                index.set(name, (bucket = []));
+            bucket.push(keyExpr);
+        }
+    }
+    return index;
+}
+function findOriginalKeys(dependencies, keyIndex, node, workspaceModules) {
+    for (const keyExpr of keyIndex.get(node.data.packageName) ?? []) {
         const snapshot = dependencies[keyExpr];
         const keys = keyExpr.split(', ');
         if (!keys.some((k) => k.startsWith(`${node.data.packageName}@`))) {
@@ -450,8 +477,8 @@ function findOriginalKeys(dependencies, node, workspaceModules) {
         }
     }
 }
-function findPatchedKeys(dependencies, node, resolutionVersion) {
-    for (const keyExpr of Object.keys(dependencies)) {
+function findPatchedKeys(dependencies, keyIndex, node, resolutionVersion) {
+    for (const keyExpr of keyIndex.get(node.data.packageName) ?? []) {
         const snapshot = dependencies[keyExpr];
         const keys = keyExpr.split(', ');
         if (!keys[0].startsWith(`${node.data.packageName}@patch:`)) {

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

@@ -96,6 +96,24 @@ export declare function ensureNodeNextEsmResolverRegistered(): void;
  * unaffected when both files exist. Idempotent on repeat calls.
  */
 export declare function ensureCjsResolverPatched(): void;
+/**
+ * Make Node's module resolver honor the given export conditions for the rest of
+ * the process, via `module.registerHooks()`. Used when a local plugin is loaded
+ * from source in-process (no child process to pass `--conditions` to at spawn):
+ * the hook appends the conditions to every resolution so the plugin's transitive
+ * workspace imports resolve to source the same way the plugin entry did.
+ *
+ * No-op when:
+ *   - `conditions` is empty (nothing to inject);
+ *   - every target condition is already active at startup (a spawned plugin
+ *     worker or daemon was launched with the full `--conditions` set, so Node's
+ *     resolver already honors them and the per-resolve hook would be redundant);
+ *   - `module.registerHooks` is unavailable (Node < 22.15 / < 23.5). Those
+ *     runtimes keep the `NODE_OPTIONS=--conditions` escape hatch.
+ *
+ * Idempotent and best-effort.
+ */
+export declare function ensureResolveConditionsInjected(conditions: string[]): void;
 /**
  * Whether Nx will defer to Node's native TypeScript stripping for the next
  * `.ts` load. Mirrors the gate used by `loadTsFile`/`registerTsProject` so

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

@@ -5,6 +5,7 @@ exports.forceRegisterEsmLoader = forceRegisterEsmLoader;
 exports.nodeNextEsmResolveHook = nodeNextEsmResolveHook;
 exports.ensureNodeNextEsmResolverRegistered = ensureNodeNextEsmResolverRegistered;
 exports.ensureCjsResolverPatched = ensureCjsResolverPatched;
+exports.ensureResolveConditionsInjected = ensureResolveConditionsInjected;
 exports.isNativeStripPreferred = isNativeStripPreferred;
 exports.registerTsProject = registerTsProject;
 exports.getSwcTranspiler = getSwcTranspiler;
@@ -388,6 +389,86 @@ const isInvokedByTsx = (() => {
     return (requireArgs.some((a) => isTsxPath(a)) ||
         importArgs.some((a) => isTsxPath(a)));
 })();
+let resolveConditionsInjected = false;
+/**
+ * Make Node's module resolver honor the given export conditions for the rest of
+ * the process, via `module.registerHooks()`. Used when a local plugin is loaded
+ * from source in-process (no child process to pass `--conditions` to at spawn):
+ * the hook appends the conditions to every resolution so the plugin's transitive
+ * workspace imports resolve to source the same way the plugin entry did.
+ *
+ * No-op when:
+ *   - `conditions` is empty (nothing to inject);
+ *   - every target condition is already active at startup (a spawned plugin
+ *     worker or daemon was launched with the full `--conditions` set, so Node's
+ *     resolver already honors them and the per-resolve hook would be redundant);
+ *   - `module.registerHooks` is unavailable (Node < 22.15 / < 23.5). Those
+ *     runtimes keep the `NODE_OPTIONS=--conditions` escape hatch.
+ *
+ * Idempotent and best-effort.
+ */
+function ensureResolveConditionsInjected(conditions) {
+    if (resolveConditionsInjected)
+        return;
+    resolveConditionsInjected = true;
+    if (!conditions.length)
+        return;
+    // Skip only when Node already honors every target condition (e.g. a worker or
+    // daemon spawned with the full `--conditions` set); a partial overlap still
+    // needs the hook to add the missing ones.
+    const activeConditions = getConditionsActiveAtStartup();
+    if (conditions.every((condition) => activeConditions.has(condition)))
+        return;
+    const module = require('node:module');
+    const registerHooks = module.registerHooks;
+    if (typeof registerHooks !== 'function')
+        return;
+    try {
+        registerHooks.call(module, {
+            resolve(specifier, context, nextResolve) {
+                const merged = context.conditions
+                    ? [...context.conditions, ...conditions]
+                    : conditions;
+                return nextResolve(specifier, { ...context, conditions: merged });
+            },
+        });
+    }
+    catch {
+        // Best-effort: leave Node's native resolution in place rather than failing.
+    }
+}
+/**
+ * Export conditions this process was started with, parsed from `--conditions`
+ * (or its `-C` alias) in `process.execArgv` and `NODE_OPTIONS`. Node's resolver
+ * already honors these, so the injected hook only needs to cover target
+ * conditions not present here.
+ */
+function getConditionsActiveAtStartup() {
+    const active = new Set();
+    const collect = (tokens) => {
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token === '--conditions' || token === '-C') {
+                const value = tokens[i + 1];
+                if (value) {
+                    active.add(value);
+                    i++;
+                }
+            }
+            else if (token.startsWith('--conditions=')) {
+                active.add(token.slice('--conditions='.length));
+            }
+            else if (token.startsWith('-C=')) {
+                active.add(token.slice('-C='.length));
+            }
+        }
+    };
+    collect(process.execArgv ?? []);
+    const nodeOptions = process.env.NODE_OPTIONS;
+    if (nodeOptions)
+        collect(nodeOptions.split(/\s+/).filter(Boolean));
+    return active;
+}
 /**
  * Whether the current Node.js runtime exposes native TypeScript type
  * stripping. This is the authoritative gate - it correctly handles every

package/dist/src/plugins/js/utils/typescript.d.ts

@@ -20,4 +20,13 @@ export declare function getRootTsConfigCustomConditions(root?: string): string[]
  * `migrate-development-custom-condition` (21.5).
  */
 export declare function getRootTsConfigResolveExportsConditions(root?: string): string[];
+/**
+ * Node `--conditions <name>` CLI args for spawning a plugin worker or the daemon
+ * with the plugin-resolution conditions active at startup. Mirrors the set Nx
+ * uses to resolve the plugin entry (`getRootTsConfigResolveExportsConditions`)
+ * so the entry and the plugin's transitive workspace imports resolve the same
+ * way; Node's own resolver otherwise ignores TypeScript `customConditions` and a
+ * source-loaded plugin's imports land on their unbuilt `dist`.
+ */
+export declare function getPluginResolveConditionNodeArgs(root?: string): string[];
 export declare function findNodes(node: Node, kind: SyntaxKind | SyntaxKind[], max?: number): Node[];

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

@@ -8,6 +8,7 @@ exports.getRootTsConfigFileName = getRootTsConfigFileName;
 exports.getRootTsConfigPath = getRootTsConfigPath;
 exports.getRootTsConfigCustomConditions = getRootTsConfigCustomConditions;
 exports.getRootTsConfigResolveExportsConditions = getRootTsConfigResolveExportsConditions;
+exports.getPluginResolveConditionNodeArgs = getPluginResolveConditionNodeArgs;
 exports.findNodes = findNodes;
 const workspace_root_1 = require("../../../utils/workspace-root");
 const fs_1 = require("fs");
@@ -113,6 +114,20 @@ function getRootTsConfigResolveExportsConditions(root = workspace_root_1.workspa
         ? conditions
         : [...conditions, 'development'];
 }
+/**
+ * Node `--conditions <name>` CLI args for spawning a plugin worker or the daemon
+ * with the plugin-resolution conditions active at startup. Mirrors the set Nx
+ * uses to resolve the plugin entry (`getRootTsConfigResolveExportsConditions`)
+ * so the entry and the plugin's transitive workspace imports resolve the same
+ * way; Node's own resolver otherwise ignores TypeScript `customConditions` and a
+ * source-loaded plugin's imports land on their unbuilt `dist`.
+ */
+function getPluginResolveConditionNodeArgs(root = workspace_root_1.workspaceRoot) {
+    return getRootTsConfigResolveExportsConditions(root).flatMap((c) => [
+        '--conditions',
+        c,
+    ]);
+}
 function findNodes(node, kind, max = Infinity) {
     if (!node || max == 0) {
         return [];

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

@@ -242,9 +242,48 @@ class AggregateCreateNodesError extends Error {
                 errorTuple.length === 2)) {
             throw new Error('AggregateCreateNodesError must be constructed with an array of tuples where the first element is a filename or undefined and the second element is the underlying error.');
         }
+        // Plugins pass through whatever value they caught, which is not
+        // guaranteed to be an Error. Coerce so formatting can rely on
+        // message and stack being present.
+        for (const errorTuple of errors) {
+            errorTuple[1] = coerceToError(errorTuple[1]);
+        }
     }
 }
 exports.AggregateCreateNodesError = AggregateCreateNodesError;
+function coerceToError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    let message;
+    let stack;
+    if (typeof value === 'object' && value !== null) {
+        const candidate = value;
+        if (typeof candidate.message === 'string') {
+            message = candidate.message;
+            if (typeof candidate.stack === 'string') {
+                stack = candidate.stack;
+            }
+        }
+        else {
+            try {
+                message = JSON.stringify(value);
+            }
+            catch {
+                // Circular structures cannot be stringified.
+                message = String(value);
+            }
+        }
+    }
+    else {
+        message = String(value);
+    }
+    const error = new Error(message);
+    // A synthesized stack would point at this coercion site rather than
+    // the original failure, so prefer the original stack or just the message.
+    error.stack = stack ?? message;
+    return error;
+}
 function formatAggregateCreateNodesError(error, pluginName) {
     const errorCount = error.errors.length > 1 ? `${error.errors.length} errors` : 'An error';
     const pluginLocation = error.pluginIndex
@@ -270,7 +309,8 @@ function formatAggregateCreateNodesError(error, pluginName) {
         }
         for (const e of errors) {
             const messageLines = e.message.split('\n');
-            const stackLines = e.stack.split('\n');
+            // Errors deserialized from a plugin worker may arrive without a stack.
+            const stackLines = (e.stack ?? e.message).split('\n');
             if (file) {
                 errorBodyLines.push(...messageLines.map((line) => `      ${line}`));
                 errorStackLines.push(...stackLines.map((line) => `     ${line}`));

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

@@ -7,6 +7,7 @@ const path = require("path");
 const logger_1 = require("../../../daemon/logger");
 const socket_utils_1 = require("../../../daemon/socket-utils");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+const typescript_1 = require("../../../plugins/js/utils/typescript");
 const installation_directory_1 = require("../../../utils/installation-directory");
 const logger_2 = require("../../../utils/logger");
 const progress_topics_1 = require("../../../utils/progress-topics");
@@ -353,6 +354,9 @@ async function startPluginWorker(name) {
     };
     const ipcPath = (0, socket_utils_1.getPluginOsSocketPath)([process.pid, global.nxPluginWorkerCount++, performance.now()].join('-'));
     const worker = (0, child_process_1.spawn)(process.execPath, [
+        // Spawn the worker with the same resolve conditions Nx uses for plugin
+        // entries so the plugin's transitive workspace imports resolve to source.
+        ...(0, typescript_1.getPluginResolveConditionNodeArgs)(),
         ...(isWorkerTypescript ? ['--require', 'ts-node/register'] : []),
         workerPath,
         ipcPath,