nx 23.1.0 → 23.1.1

package/dist/src/native/index.d.ts

@@ -326,6 +326,7 @@ export interface EventDimensions {
   packageName: string
   packageVersion: string
   duration: string
+  sampleRate: string
   taskCount: string
   projectCount: string
   cachedTaskCount: string
@@ -487,14 +488,14 @@ export interface HashInputs {
  * so the caller can set it as an env var for child processes.
  * Used by CLI and daemon.
  */
-export declare function initializeTelemetry(connection: ExternalObject<NxDbConnection>, workspaceId: string, userId: string, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): string
+export declare function initializeTelemetry(connection: ExternalObject<NxDbConnection>, workspaceId: string, userId: string | undefined | null, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): string
 
 /**
  * Initialize telemetry with a pre-fetched session ID.
  * No DB connection — used by plugin workers that inherit the
  * session ID from their parent process via env var.
  */
-export declare function initializeTelemetryWithSessionId(sessionId: string, workspaceId: string, userId: string, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): void
+export declare function initializeTelemetryWithSessionId(sessionId: string, workspaceId: string, userId: string | undefined | null, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): void
 
 export interface InputsInput {
   input: string
@@ -557,6 +558,24 @@ export interface Link {
 
 export declare function logDebug(message: string): void
 
+/**
+ * Checks which `paths` match the given `globs`, using the same glob engine
+ * as the task hasher (`build_glob_set`). Used to statically match
+ * `dependentTasksOutputFiles` globs against candidate paths.
+ */
+export declare function matchGlobPaths(globs: Array<string>, paths: Array<string>): Array<boolean>
+
+/**
+ * Statically checks which `paths` would be captured by the given output
+ * `entries`, without touching the file system. Mirrors `expand_outputs`
+ * semantics: entries match themselves and anything nested under them (so a
+ * directory entry captures its contents), negated (`!`-prefixed) entries
+ * exclude matches from the whole entry set, and a non-empty list with only
+ * negated entries matches everything not excluded. An empty list matches
+ * nothing.
+ */
+export declare function matchOutputPaths(entries: Array<string>, paths: Array<string>): Array<boolean>
+
 /** Combined metadata for groups and processes */
 export interface Metadata {
   /** Group-level metadata */

package/dist/src/native/native-bindings.js

@@ -625,6 +625,8 @@ module.exports.isEditorInstalled = nativeBinding.isEditorInstalled
 module.exports.killProcessTree = nativeBinding.killProcessTree
 module.exports.killProcessTreeGraceful = nativeBinding.killProcessTreeGraceful
 module.exports.logDebug = nativeBinding.logDebug
+module.exports.matchGlobPaths = nativeBinding.matchGlobPaths
+module.exports.matchOutputPaths = nativeBinding.matchOutputPaths
 module.exports.parseTaskStatus = nativeBinding.parseTaskStatus
 module.exports.remove = nativeBinding.remove
 module.exports.restoreTerminal = nativeBinding.restoreTerminal

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,
                 });
             }
         }
@@ -178,7 +183,8 @@ function getNodes(data, isV5) {
         }
     }
     const packageNames = new Set();
-    for (const [key, snapshot] of Object.entries(data.packages)) {
+    // pnpm omits the packages block for workspace-only lockfiles (no external deps)
+    for (const [key, snapshot] of Object.entries(data.packages ?? {})) {
         let packageNameObj;
         const originalPackageName = extractNameFromKey(key, isV5);
         if (!originalPackageName) {
@@ -359,7 +365,8 @@ function getHoistedVersion(packageName, isV5, hoistedKeysByPackage) {
 }
 function getDependencies(data, keyMap, isV5, ctx) {
     const results = [];
-    Object.keys(data.packages).forEach((key) => {
+    // pnpm omits the packages block for workspace-only lockfiles (no external deps)
+    Object.keys(data.packages ?? {}).forEach((key) => {
         const snapshot = data.packages[key];
         const nodes = keyMap.get(key);
         nodes.forEach((node) => {
@@ -391,9 +398,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 +465,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 +508,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 +595,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 +609,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 +645,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/utils/pnpm-normalizer.js

@@ -54,6 +54,9 @@ const YAML_DOCUMENT_SEPARATOR = '\n---\n';
 // always read the workspace document.
 // https://github.com/pnpm/pnpm/blob/main/lockfile/fs/src/yamlDocuments.ts
 function extractMainLockfileDocument(content) {
+    // Lockfiles written on Windows may use CRLF line endings, which would never
+    // match the LF-only document markers.
+    content = content.replace(/\r\n/g, '\n');
     if (!content.startsWith(YAML_DOCUMENT_START)) {
         return content;
     }

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/project-graph/build-dependencies/target-project-locator.js

@@ -161,11 +161,19 @@ class TargetProjectLocator {
                 return externalNodeName;
             }
             const version = (0, semver_1.clean)(externalPackageJson.version);
-            let matchingExternalNode = this.npmProjects[`npm:${externalPackageJson.name}@${version}`];
-            if (!matchingExternalNode) {
-                // check if it's a package alias, where the resolved package key is used as the version
+            const isAliasImport = packageName !== externalPackageJson.name;
+            let matchingExternalNode = null;
+            if (isAliasImport) {
+                // Prefer the alias node when both the alias import and the resolved package
+                // exist in the graph, otherwise generated package.json files lose the alias key.
                 const aliasNpmProjectKey = `npm:${packageName}@npm:${externalPackageJson.name}@${version}`;
-                matchingExternalNode = this.npmProjects[aliasNpmProjectKey];
+                matchingExternalNode =
+                    this.npmProjects[aliasNpmProjectKey] ??
+                        this.npmProjects[`npm:${packageName}`];
+            }
+            if (!matchingExternalNode) {
+                matchingExternalNode =
+                    this.npmProjects[`npm:${externalPackageJson.name}@${version}`];
             }
             if (!matchingExternalNode) {
                 // Fallback to package name as key. This can happen if the version in project graph is not the same as in the resolved package.json.

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