nx 23.0.1 → 23.0.2

package/dist/src/daemon/server/project-graph-incremental-recomputation.js

@@ -178,9 +178,26 @@ async function getCachedSerializedProjectGraphPromise(socket) {
 }
 function scheduleProjectGraphRecomputation(createdFiles, updatedFiles, deletedFiles) {
     ++fileChangeCounter;
-    for (let f of [...createdFiles, ...updatedFiles]) {
+    // Hash the changed files up front and drop no-op rewrites before they can
+    // trigger an expensive recompute. Restoring a cached task output, a
+    // `git checkout` back to the same content, or a formatter that changes
+    // nothing all rewrite a file (new inode) the watcher reports as changed
+    // even though the bytes are identical. updateFilesInContext updates the
+    // workspace context and returns only the files whose content actually
+    // changed. Hashing here — once per watcher batch — rather than inside the
+    // recompute keeps it off the stale-retry path, which would otherwise see
+    // "no change" after the first pass already updated the context hashes.
+    perf_hooks_1.performance.mark('hash-watched-changes-start');
+    const changedFileHashes = createdFiles.length > 0 ||
+        updatedFiles.length > 0 ||
+        deletedFiles.length > 0
+        ? ((0, workspace_context_1.updateFilesInContext)(workspace_root_1.workspaceRoot, [...createdFiles, ...updatedFiles], deletedFiles) ?? {})
+        : {};
+    perf_hooks_1.performance.mark('hash-watched-changes-end');
+    perf_hooks_1.performance.measure('hash changed files from watcher', 'hash-watched-changes-start', 'hash-watched-changes-end');
+    for (const [f, hash] of Object.entries(changedFileHashes)) {
         collectedDeletedFiles.delete(f);
-        collectedUpdatedFiles.set(f, fileChangeCounter);
+        collectedUpdatedFiles.set(f, { version: fileChangeCounter, hash });
     }
     for (let f of deletedFiles) {
         collectedUpdatedFiles.delete(f);
@@ -188,9 +205,7 @@ function scheduleProjectGraphRecomputation(createdFiles, updatedFiles, deletedFi
     }
     // The native watcher already coalesces a burst of events into one batch,
     // so socket + listener notifications dispatch immediately.
-    if (createdFiles.length > 0 ||
-        updatedFiles.length > 0 ||
-        deletedFiles.length > 0) {
+    if (Object.keys(changedFileHashes).length > 0 || deletedFiles.length > 0) {
         (0, file_change_events_1.notifyFileChangeListeners)({ createdFiles, updatedFiles, deletedFiles });
         (0, file_watcher_sockets_1.notifyFileWatcherSockets)(createdFiles, updatedFiles, deletedFiles);
         // Bump generation synchronously so any in-flight compute fails its
@@ -284,14 +299,18 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         return cachedSerializedProjectGraphPromise;
     };
     try {
-        perf_hooks_1.performance.mark('hash-watched-changes-start');
         const updatedFilesSnapshot = new Map(collectedUpdatedFiles);
         const deletedFilesSnapshot = new Map(collectedDeletedFiles);
         const updatedFiles = [...updatedFilesSnapshot.keys()];
         const deletedFiles = [...deletedFilesSnapshot.keys()];
-        let updatedFileHashes = (0, workspace_context_1.updateFilesInContext)(workspace_root_1.workspaceRoot, updatedFiles, deletedFiles);
-        perf_hooks_1.performance.mark('hash-watched-changes-end');
-        perf_hooks_1.performance.measure('hash changed files from watcher', 'hash-watched-changes-start', 'hash-watched-changes-end');
+        // Hashes were already computed (and the workspace context updated) in
+        // scheduleProjectGraphRecomputation, which also dropped no-op rewrites.
+        // Reuse them so the context isn't re-hashed on every (possibly stale)
+        // recompute attempt.
+        const updatedFileHashes = {};
+        for (const [f, { hash }] of updatedFilesSnapshot) {
+            updatedFileHashes[f] = hash;
+        }
         logger_1.serverLogger.requestLog(`Updated workspace context based on watched changes, recomputing project graph...`);
         logger_1.serverLogger.requestLog(updatedFiles);
         logger_1.serverLogger.requestLog(deletedFiles);
@@ -333,8 +352,8 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         // from the daemon's view (project graph misses recently added files).
         // Match version-stamps so a file modified mid-flight (higher version)
         // stays in the queue for reprocessing.
-        for (const [f, version] of updatedFilesSnapshot) {
-            if (collectedUpdatedFiles.get(f) === version) {
+        for (const [f, { version }] of updatedFilesSnapshot) {
+            if (collectedUpdatedFiles.get(f)?.version === version) {
                 collectedUpdatedFiles.delete(f);
             }
         }

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

@@ -26,6 +26,10 @@ let cachedPackageIndex;
 const keyMap = new Map();
 const packageVersions = new Map();
 const specParseCache = new Map();
+// Memoizes (packageName, versionSpec) -> resolved version for the current
+// lockfile. The same name/range pairs repeat across many dependency lists, so
+// the semver resolution is done once per distinct pair instead of per edge.
+const resolvedVersionCache = new Map();
 // Structured error types for better error handling
 class BunLockfileParseError extends Error {
     constructor(message, cause) {
@@ -72,6 +76,7 @@ function clearCache() {
     keyMap.clear();
     packageVersions.clear();
     specParseCache.clear();
+    resolvedVersionCache.clear();
 }
 // ===== UTILITY FUNCTIONS =====
 function getCachedSpecInfo(resolvedSpec) {
@@ -732,40 +737,38 @@ function createHoistedNodes(packageVersions, lockFile, index, keyMap, nodes) {
  * O(1) lookup using pre-computed index
  */
 function isNestedPackageKey(packageKey, index) {
-    // If the key doesn't contain '/', it's a direct package entry
-    if (!packageKey.includes('/')) {
+    // If the key doesn't contain '/', it's a direct package entry.
+    // Work off slash indices instead of split('/')+slice+join to avoid an
+    // array allocation per key (this runs for every package entry, twice).
+    const lastSlash = packageKey.lastIndexOf('/');
+    if (lastSlash === -1) {
         return false;
     }
-    // Check if this looks like a workspace-specific or nested entry
-    const parts = packageKey.split('/');
-    // For multi-part keys, check if the prefix is a workspace path or package name
-    if (parts.length >= 2) {
-        const prefix = parts.slice(0, -1).join('/');
-        // O(1) check against known workspace paths
-        if (index.workspacePaths.has(prefix)) {
-            return true;
-        }
-        // O(1) check against workspace package names (scoped packages)
-        if (index.workspaceNames.has(prefix)) {
-            return true;
-        }
-        // Check for scoped workspace packages (e.g., "@quz/pkg1/lodash")
-        // The prefix must contain '/' to be a scoped package (e.g., "@scope/pkg")
-        // A prefix like just "@scope" without '/' is not a scoped package
-        if (prefix.startsWith('@') && prefix.includes('/')) {
-            return true;
-        }
-        // If the key looks like a simple scoped package (e.g., "@custom/lodash")
-        // where parts.length === 2 and first part starts with '@', it's likely
-        // a scoped package alias, not a nested dependency
-        if (parts.length === 2 && parts[0].startsWith('@')) {
-            return false;
-        }
-        // This could be dependency nesting (e.g., "is-even/is-odd")
-        // These should be filtered out as they're not direct packages
+    // prefix = everything before the last '/'
+    const prefix = packageKey.substring(0, lastSlash);
+    // O(1) check against known workspace paths
+    if (index.workspacePaths.has(prefix)) {
         return true;
     }
-    return false;
+    // O(1) check against workspace package names (scoped packages)
+    if (index.workspaceNames.has(prefix)) {
+        return true;
+    }
+    // Check for scoped workspace packages (e.g., "@quz/pkg1/lodash")
+    // The prefix must contain '/' to be a scoped package (e.g., "@scope/pkg")
+    // A prefix like just "@scope" without '/' is not a scoped package
+    if (prefix.startsWith('@') && prefix.includes('/')) {
+        return true;
+    }
+    // If the key looks like a simple scoped package (e.g., "@custom/lodash")
+    // with a single '/' where the first segment starts with '@', it's likely
+    // a scoped package alias, not a nested dependency
+    if (packageKey.indexOf('/') === lastSlash && packageKey.startsWith('@')) {
+        return false;
+    }
+    // This could be dependency nesting (e.g., "is-even/is-odd")
+    // These should be filtered out as they're not direct packages
+    return true;
 }
 /**
  * Determines if a package should have a hoisted node created
@@ -829,6 +832,18 @@ function getHoistedVersion(packageName, availableVersions, index) {
  * O(1) lookup using pre-computed index instead of O(n) scan through all packages
  */
 function findResolvedVersion(packageName, versionSpec, index, manifests) {
+    // Resolution depends only on (packageName, versionSpec) for a given lockfile
+    // (index and manifests are constant per parse), so memoize across edges.
+    const cacheKey = `${packageName}\n${versionSpec}`;
+    const cached = resolvedVersionCache.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const resolved = computeResolvedVersion(packageName, versionSpec, index, manifests);
+    resolvedVersionCache.set(cacheKey, resolved);
+    return resolved;
+}
+function computeResolvedVersion(packageName, versionSpec, index, manifests) {
     // O(1) lookup
     const candidates = index.byName.get(packageName);
     if (!candidates || candidates.length === 0) {
@@ -918,19 +933,27 @@ function findBestVersionMatch(versionSpec, candidates) {
         // No satisfying versions found, return the first semver candidate as fallback
         return semverVersions[0].version;
     }
-    // Return the highest satisfying version (similar to npm behavior)
-    // Sort versions in descending order and return the first one
-    const sortedVersions = satisfyingVersions.sort((a, b) => {
+    // Return the highest satisfying version (similar to npm behavior).
+    // Single-pass max instead of a full sort: only the top element is used, and
+    // the numeric-collation comparator is expensive, so O(n) comparisons beat
+    // O(n log n). Keeps the first element on ties, matching the previous stable
+    // descending sort followed by [0].
+    let best = satisfyingVersions[0];
+    for (let i = 1; i < satisfyingVersions.length; i++) {
+        const candidate = satisfyingVersions[i];
+        let cmp;
         try {
-            return b.version.localeCompare(a.version, undefined, {
+            cmp = candidate.version.localeCompare(best.version, undefined, {
                 numeric: true,
                 sensitivity: 'base',
             });
         }
         catch {
-            // Fallback to string comparison
-            return b.version.localeCompare(a.version);
+            cmp = candidate.version.localeCompare(best.version);
         }
-    });
-    return sortedVersions[0].version;
+        if (cmp > 0) {
+            best = candidate;
+        }
+    }
+    return best.version;
 }

package/dist/src/plugins/js/lock-file/utils/pnpm-normalizer.js

@@ -36,9 +36,7 @@ function loadPnpmHoistedDepsDefinition() {
         const { load } = require('@zkochan/js-yaml');
         return load(content)?.hoistedDependencies ?? {};
     }
-    else {
-        throw new Error(`Could not find ".modules.yaml" at "${fullPath}"`);
-    }
+    throw new Error(`pnpm lockfile detected, but "${fullPath}" is missing. This usually means that "node_modules" was not installed with pnpm. Run "pnpm install" or use a single package manager for this workspace.`);
 }
 /**
  * Parsing and mapping logic from pnpm lockfile `read` function

package/dist/src/plugins/js/package-json/create-package-json.js

@@ -136,10 +136,31 @@ function createPackageJson(projectName, graph, options = {}, fileMap = null) {
     // region Overrides/Resolutions
     // npm
     if (rootPackageJson.overrides && !options.skipOverrides) {
-        packageJson.overrides = {
+        // npm throws EOVERRIDE when an override key is also a direct dependency
+        // (unless specs match). The pruned dist pins exact versions and already
+        // resolved everything via the lockfile, so drop those redundant overrides.
+        const mergedOverrides = {
             ...rootPackageJson.overrides,
             ...packageJson.overrides,
         };
+        const overrides = {};
+        let hasOverrides = false;
+        for (const name in mergedOverrides) {
+            if (packageJson.dependencies?.[name] ||
+                packageJson.devDependencies?.[name] ||
+                packageJson.peerDependencies?.[name] ||
+                packageJson.optionalDependencies?.[name]) {
+                continue;
+            }
+            overrides[name] = mergedOverrides[name];
+            hasOverrides = true;
+        }
+        if (hasOverrides) {
+            packageJson.overrides = overrides;
+        }
+        else {
+            delete packageJson.overrides;
+        }
     }
     // pnpm
     if (rootPackageJson.pnpm?.overrides && !options.skipOverrides) {

package/dist/src/plugins/js/project-graph/build-dependencies/target-project-locator.d.ts

@@ -56,6 +56,13 @@ export declare class TargetProjectLocator {
     private resolveImportWithTypescript;
     private resolveImportWithRequire;
     private findProjectOfResolvedModule;
+    /**
+     * Expand a `${configDir}` path mapping the same way TypeScript does. The
+     * template resolves to the directory of the tsconfig used for compilation,
+     * which for the importing file is its own project, so a configDir alias always
+     * points back into the source project (matching what `tsc` resolves).
+     */
+    private substituteConfigDirTemplate;
     private getAbsolutePath;
     private getRootTsConfig;
     private findMatchingProjectFiles;

package/dist/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -22,6 +22,12 @@ function isBuiltinModuleImport(importExpr) {
     const packageName = (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(importExpr);
     return (0, node_module_1.isBuiltin)(packageName) || experimentalNodeModules.has(packageName);
 }
+// TypeScript matches the `${configDir}` template case-insensitively and only as a
+// prefix (commandLineParser.ts `startsWithConfigDirTemplate`).
+const configDirTemplate = '${configDir}';
+function startsWithConfigDirTemplate(value) {
+    return value.toLowerCase().startsWith(configDirTemplate.toLowerCase());
+}
 class TargetProjectLocator {
     constructor(nodes, externalNodes = {}, npmResolutionCache = defaultNpmResolutionCache, packageJsonResolutionCache = defaultPackageJsonResolutionCache) {
         this.nodes = nodes;
@@ -75,7 +81,10 @@ class TargetProjectLocator {
                 ? undefined
                 : importExpr.substring(path.prefix.length, importExpr.length - path.suffix.length);
             for (let p of paths) {
-                const path = matchedStar ? p.replace('*', matchedStar) : p;
+                let path = matchedStar ? p.replace('*', matchedStar) : p;
+                if (startsWithConfigDirTemplate(path)) {
+                    path = this.substituteConfigDirTemplate(path, filePath);
+                }
                 const maybeResolvedProject = this.findProjectOfResolvedModule(path);
                 if (maybeResolvedProject) {
                     return maybeResolvedProject;
@@ -343,6 +352,22 @@ class TargetProjectLocator {
         const importedProject = this.findMatchingProjectFiles(normalizedResolvedModule);
         return importedProject ? importedProject.name : void 0;
     }
+    /**
+     * Expand a `${configDir}` path mapping the same way TypeScript does. The
+     * template resolves to the directory of the tsconfig used for compilation,
+     * which for the importing file is its own project, so a configDir alias always
+     * points back into the source project (matching what `tsc` resolves).
+     */
+    substituteConfigDirTemplate(value, filePath) {
+        const sourceFilePath = (0, node_path_1.isAbsolute)(filePath)
+            ? (0, node_path_1.relative)(workspace_root_1.workspaceRoot, filePath)
+            : filePath;
+        const sourceProjectName = (0, find_project_for_path_1.findProjectForPath)(sourceFilePath, this.projectRootMappings);
+        const sourceProjectRoot = this.nodes[sourceProjectName]?.data.root ?? '.';
+        // tsc replaces the template with './' and normalizes against the config dir;
+        // here the config dir is the source project root (workspace-relative).
+        return node_path_1.posix.join(sourceProjectRoot, value.replace(configDirTemplate, './'));
+    }
     getAbsolutePath(path) {
         return (0, node_path_1.join)(workspace_root_1.workspaceRoot, path);
     }

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

@@ -35,22 +35,43 @@ export declare function forceRegisterEsmLoader(): void;
  * the importing module is itself TypeScript, and the specifier is relative, so
  * it never hijacks resolution that would otherwise succeed.
  *
+ * Used only as the fallback for runtimes without `module.registerHooks()`
+ * (Node < 22.15 / < 23.5); newer runtimes register the in-thread synchronous
+ * twin `nodeNextEsmResolveHook` instead. Keep the two in sync.
+ *
  * Exported so the hook can be exercised directly in unit tests.
  */
 export declare const NODENEXT_ESM_RESOLVER_SOURCE = "\nconst EXT_FALLBACK = { '.js': ['.ts', '.tsx'], '.mjs': ['.mts'], '.cjs': ['.cts'] };\nconst TS_PARENT_RE = /\\.(?:ts|tsx|mts|cts)(?:$|\\?)/;\nexport async function resolve(specifier, context, nextResolve) {\n  try {\n    return await nextResolve(specifier, context);\n  } catch (err) {\n    if (err?.code !== 'ERR_MODULE_NOT_FOUND') throw err;\n    const parent = context.parentURL;\n    if (!parent || !TS_PARENT_RE.test(parent)) throw err;\n    if (!(specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('file:'))) throw err;\n    const m = specifier.match(/(\\.(?:js|mjs|cjs))($|\\?)/);\n    if (!m) throw err;\n    const fallbacks = EXT_FALLBACK[m[1]];\n    if (!fallbacks) throw err;\n    const base = specifier.slice(0, m.index);\n    const suffix = specifier.slice(m.index + m[1].length);\n    for (const ext of fallbacks) {\n      try { return await nextResolve(base + ext + suffix, context); } catch {}\n    }\n    throw err;\n  }\n}\n";
 /**
- * Register a self-contained ESM resolution hook (via `Module.register`) that
- * rewrites TypeScript NodeNext-style `.js`/`.mjs`/`.cjs` relative specifiers to
- * their `.ts`/`.mts`/`.cts` sources. This is the ESM counterpart to
- * `ensureCjsResolverPatched`: Node's native type stripping loads the `.ts`
- * file, but neither native strip nor Node's ESM resolver rewrites the
- * extension, so `import './foo.js'` from a `.ts` source where only `foo.ts`
- * exists fails with ERR_MODULE_NOT_FOUND without it.
+ * Synchronous in-thread twin of `NODENEXT_ESM_RESOLVER_SOURCE` for
+ * `module.registerHooks()`: `nextResolve` throws synchronously rather than
+ * rejecting, so this uses try/catch instead of `await`. Keep the two in sync.
+ * Exported for unit tests.
+ */
+export declare function nodeNextEsmResolveHook(specifier: string, context: {
+    parentURL?: string;
+}, nextResolve: (specifier: string, context?: unknown) => {
+    url: string;
+}): {
+    url: string;
+};
+/**
+ * Register an ESM resolution hook that rewrites TypeScript NodeNext-style
+ * `.js`/`.mjs`/`.cjs` relative specifiers to their `.ts`/`.mts`/`.cts` sources.
+ * This is the ESM counterpart to `ensureCjsResolverPatched`: Node's native type
+ * stripping loads the `.ts` file, but neither native strip nor Node's ESM
+ * resolver rewrites the extension, so `import './foo.js'` from a `.ts` source
+ * where only `foo.ts` exists fails with ERR_MODULE_NOT_FOUND without it.
  *
- * The hook is inlined as a `data:` module (see `NODENEXT_ESM_RESOLVER_SOURCE`)
- * and relies only on Node's default resolver, so it needs no ts-node/swc-node.
+ * Prefers `module.registerHooks()` (Node 22.15+ / 23.5+), passing the in-thread
+ * `nodeNextEsmResolveHook`. Falls back to `module.register()` with the inlined
+ * `data:` module (`NODENEXT_ESM_RESOLVER_SOURCE`) on older runtimes that lack
+ * `registerHooks` - `module.register()` emits a runtime DeprecationWarning
+ * (DEP0205) on Node 25.9+/26+, so it is only used when nothing better exists.
+ * Either way the hook relies only on Node's default resolver - no
+ * ts-node/swc-node.
  *
- * Idempotent and best-effort: a no-op when `Module.register` is unavailable,
+ * Idempotent and best-effort: a no-op when no registration API is available,
  * when a TypeScript transpiler is already preloaded (see
  * `isTsTranspilerPreloaded`), or if registration fails.
  */

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NODENEXT_ESM_RESOLVER_SOURCE = void 0;
 exports.forceRegisterEsmLoader = forceRegisterEsmLoader;
+exports.nodeNextEsmResolveHook = nodeNextEsmResolveHook;
 exports.ensureNodeNextEsmResolverRegistered = ensureNodeNextEsmResolverRegistered;
 exports.ensureCjsResolverPatched = ensureCjsResolverPatched;
 exports.isNativeStripPreferred = isNativeStripPreferred;
@@ -100,6 +101,10 @@ function ensureEsmLoaderRegistered(opts) {
  * the importing module is itself TypeScript, and the specifier is relative, so
  * it never hijacks resolution that would otherwise succeed.
  *
+ * Used only as the fallback for runtimes without `module.registerHooks()`
+ * (Node < 22.15 / < 23.5); newer runtimes register the in-thread synchronous
+ * twin `nodeNextEsmResolveHook` instead. Keep the two in sync.
+ *
  * Exported so the hook can be exercised directly in unit tests.
  */
 exports.NODENEXT_ESM_RESOLVER_SOURCE = `
@@ -126,20 +131,70 @@ export async function resolve(specifier, context, nextResolve) {
   }
 }
 `;
+const NODENEXT_EXT_FALLBACK = {
+    '.js': ['.ts', '.tsx'],
+    '.mjs': ['.mts'],
+    '.cjs': ['.cts'],
+};
+const NODENEXT_TS_PARENT_RE = /\.(?:ts|tsx|mts|cts)(?:$|\?)/;
+/**
+ * Synchronous in-thread twin of `NODENEXT_ESM_RESOLVER_SOURCE` for
+ * `module.registerHooks()`: `nextResolve` throws synchronously rather than
+ * rejecting, so this uses try/catch instead of `await`. Keep the two in sync.
+ * Exported for unit tests.
+ */
+function nodeNextEsmResolveHook(specifier, context, nextResolve) {
+    try {
+        return nextResolve(specifier, context);
+    }
+    catch (err) {
+        if (err?.code !== 'ERR_MODULE_NOT_FOUND')
+            throw err;
+        const parent = context.parentURL;
+        if (!parent || !NODENEXT_TS_PARENT_RE.test(parent))
+            throw err;
+        if (!(specifier.startsWith('./') ||
+            specifier.startsWith('../') ||
+            specifier.startsWith('file:'))) {
+            throw err;
+        }
+        const m = specifier.match(/(\.(?:js|mjs|cjs))($|\?)/);
+        if (!m)
+            throw err;
+        const fallbacks = NODENEXT_EXT_FALLBACK[m[1]];
+        if (!fallbacks)
+            throw err;
+        const base = specifier.slice(0, m.index);
+        const suffix = specifier.slice(m.index + m[1].length);
+        for (const ext of fallbacks) {
+            try {
+                return nextResolve(base + ext + suffix, context);
+            }
+            catch {
+                // try the next fallback
+            }
+        }
+        throw err;
+    }
+}
 let nodeNextEsmResolverRegistered = false;
 /**
- * Register a self-contained ESM resolution hook (via `Module.register`) that
- * rewrites TypeScript NodeNext-style `.js`/`.mjs`/`.cjs` relative specifiers to
- * their `.ts`/`.mts`/`.cts` sources. This is the ESM counterpart to
- * `ensureCjsResolverPatched`: Node's native type stripping loads the `.ts`
- * file, but neither native strip nor Node's ESM resolver rewrites the
- * extension, so `import './foo.js'` from a `.ts` source where only `foo.ts`
- * exists fails with ERR_MODULE_NOT_FOUND without it.
+ * Register an ESM resolution hook that rewrites TypeScript NodeNext-style
+ * `.js`/`.mjs`/`.cjs` relative specifiers to their `.ts`/`.mts`/`.cts` sources.
+ * This is the ESM counterpart to `ensureCjsResolverPatched`: Node's native type
+ * stripping loads the `.ts` file, but neither native strip nor Node's ESM
+ * resolver rewrites the extension, so `import './foo.js'` from a `.ts` source
+ * where only `foo.ts` exists fails with ERR_MODULE_NOT_FOUND without it.
  *
- * The hook is inlined as a `data:` module (see `NODENEXT_ESM_RESOLVER_SOURCE`)
- * and relies only on Node's default resolver, so it needs no ts-node/swc-node.
+ * Prefers `module.registerHooks()` (Node 22.15+ / 23.5+), passing the in-thread
+ * `nodeNextEsmResolveHook`. Falls back to `module.register()` with the inlined
+ * `data:` module (`NODENEXT_ESM_RESOLVER_SOURCE`) on older runtimes that lack
+ * `registerHooks` - `module.register()` emits a runtime DeprecationWarning
+ * (DEP0205) on Node 25.9+/26+, so it is only used when nothing better exists.
+ * Either way the hook relies only on Node's default resolver - no
+ * ts-node/swc-node.
  *
- * Idempotent and best-effort: a no-op when `Module.register` is unavailable,
+ * Idempotent and best-effort: a no-op when no registration API is available,
  * when a TypeScript transpiler is already preloaded (see
  * `isTsTranspilerPreloaded`), or if registration fails.
  */
@@ -148,16 +203,16 @@ function ensureNodeNextEsmResolverRegistered() {
         return;
     nodeNextEsmResolverRegistered = true;
     const module = require('node:module');
-    if (typeof module.register !== 'function')
-        return;
     // Skip when a transpiler was preloaded via `--require`/`--import` (e.g.
     // `--require ts-node/register`, which Nx uses only when it runs from `.ts`
-    // source). `module.register()` spins up a loader-hook worker thread on which
-    // Node re-runs those preloads, resolved relative to the *current* working
-    // directory - and Nx plugin workers `chdir()` into the analyzed workspace
-    // first. If that workspace can't resolve the preloaded module, the loader
-    // worker throws and can leave module resolution in a bad state, so we must
-    // avoid the call entirely; catching it is not a clean recovery.
+    // source). The `module.register()` fallback below spins up a loader-hook
+    // worker thread on which Node re-runs those preloads, resolved relative to
+    // the *current* working directory - and Nx plugin workers `chdir()` into the
+    // analyzed workspace first. If that workspace can't resolve the preloaded
+    // module, the loader worker throws and can leave module resolution in a bad
+    // state, so we must avoid the call entirely; catching it is not a clean
+    // recovery. `module.registerHooks()` runs in-thread with no such worker, but
+    // we keep the skip uniform so resolver coverage doesn't vary by Node version.
     //
     // Consequence: in that from-`.ts`-source invocation a `type: module` plugin
     // using NodeNext `.js` specifiers won't get this resolver (a preloaded
@@ -165,6 +220,20 @@ function ensureNodeNextEsmResolverRegistered() {
     // unaffected - its workers run compiled `.js` with no preload.
     if (isTsTranspilerPreloaded())
         return;
+    // Synchronous in-thread hooks (Node 22.15+ / 23.5+). Preferred because
+    // `module.register()` is deprecated (DEP0205) from Node 25.9+/26+.
+    const registerHooks = module.registerHooks;
+    if (typeof registerHooks === 'function') {
+        try {
+            registerHooks.call(module, { resolve: nodeNextEsmResolveHook });
+        }
+        catch {
+            // Best-effort: leave Node's native handling in place rather than failing.
+        }
+        return;
+    }
+    if (typeof module.register !== 'function')
+        return;
     try {
         module.register('data:text/javascript,' + encodeURIComponent(exports.NODENEXT_ESM_RESOLVER_SOURCE));
     }

package/dist/src/plugins/package-json/create-nodes.js

@@ -97,10 +97,12 @@ function buildPackageJsonPatterns(workspaceRoot, readJson) {
     };
 }
 function buildPackageJsonWorkspacesMatcher(patterns) {
+    // Compile each glob once; the returned matcher runs per package.json path.
+    const positive = patterns.positive.map((p) => new minimatch_1.Minimatch(p));
+    const negative = patterns.negative.map((p) => new minimatch_1.Minimatch(p));
     return (p) => 
     // use lookup to avoid unnecessary minimatch calls
-    (patterns.positiveLookup[p] ||
-        patterns.positive.some((positive) => (0, minimatch_1.minimatch)(p, positive))) &&
+    (patterns.positiveLookup[p] || positive.some((m) => m.match(p))) &&
         /**
          * minimatch will return true if the given p is NOT excluded by the negative pattern.
          *
@@ -111,7 +113,7 @@ function buildPackageJsonWorkspacesMatcher(patterns) {
          * excluded by any of the negative patterns.
          */
         !patterns.negativeLookup[p] &&
-        patterns.negative.every((negative) => (0, minimatch_1.minimatch)(p, negative));
+        negative.every((m) => m.match(p));
 }
 function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand) {
     const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, pkgJsonPath));

package/dist/src/project-graph/operators.d.ts

@@ -9,4 +9,3 @@ export declare function reverse(graph: ProjectGraph): ProjectGraph;
 export declare function filterNodes(predicate?: (n: ProjectGraphProjectNode) => boolean): (p: ProjectGraph) => ProjectGraph;
 export declare function isNpmProject(project: ProjectGraphProjectNode | ProjectGraphExternalNode): project is ProjectGraphExternalNode;
 export declare const pruneExternalNodes: (p: ProjectGraph) => ProjectGraph;
-export declare function withDeps(original: ProjectGraph, subsetNodes: ProjectGraphProjectNode[]): ProjectGraph;

package/dist/src/project-graph/operators.js

@@ -4,7 +4,6 @@ exports.pruneExternalNodes = void 0;
 exports.reverse = reverse;
 exports.filterNodes = filterNodes;
 exports.isNpmProject = isNpmProject;
-exports.withDeps = withDeps;
 const reverseMemo = new Map();
 /**
  * Returns a new project graph where all the edges are reversed.
@@ -69,46 +68,3 @@ function isNpmProject(project) {
     return project?.type === 'npm';
 }
 exports.pruneExternalNodes = filterNodes();
-function withDeps(original, subsetNodes) {
-    const res = { nodes: {}, dependencies: {} };
-    const visitedNodes = [];
-    const visitedEdges = [];
-    Object.values(subsetNodes).forEach(recurNodes);
-    Object.values(subsetNodes).forEach(recurEdges);
-    return res;
-    // ---------------------------------------------------------------------------
-    function recurNodes(node) {
-        if (visitedNodes.indexOf(node.name) > -1)
-            return;
-        res.nodes[node.name] = node;
-        if (!res.dependencies[node.name]) {
-            res.dependencies[node.name] = [];
-        }
-        visitedNodes.push(node.name);
-        original.dependencies[node.name].forEach((n) => {
-            if (original.nodes[n.target]) {
-                recurNodes(original.nodes[n.target]);
-            }
-        });
-    }
-    function recurEdges(node) {
-        if (visitedEdges.indexOf(node.name) > -1)
-            return;
-        visitedEdges.push(node.name);
-        const ds = original.dependencies[node.name];
-        ds.forEach((n) => {
-            if (!original.nodes[n.target]) {
-                return;
-            }
-            if (!res.dependencies[n.source]) {
-                res.dependencies[n.source] = [];
-            }
-            res.dependencies[n.source].push(n);
-        });
-        ds.forEach((n) => {
-            if (original.nodes[n.target]) {
-                recurEdges(original.nodes[n.target]);
-            }
-        });
-    }
-}