nx 23.1.1 → 23.1.2

package/dist/src/utils/assert-workspace-validity.js

@@ -3,7 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertWorkspaceValidity = assertWorkspaceValidity;
 const find_matching_projects_1 = require("./find-matching-projects");
 const output_1 = require("./output");
-const devkit_internals_1 = require("../devkit-internals");
+// Import from the defining module, not the devkit-internals barrel: this file
+// is on the project-graph construction path, and the barrel now eagerly
+// re-exports the project-graph modules, which would create a require cycle back
+// through build-project-graph. (Release modules cross the barrel as erased
+// types only — see the note in packages/devkit/internal.ts.)
+const error_types_1 = require("../project-graph/error-types");
 function assertWorkspaceValidity(projects, nxJson) {
     const projectNames = Object.keys(projects);
     const projectGraphNodes = projectNames.reduce((graph, project) => {
@@ -65,7 +70,7 @@ function assertWorkspaceValidity(projects, nxJson) {
         })
             .join('\n\n');
     }
-    throw new devkit_internals_1.WorkspaceValidityError(message);
+    throw new error_types_1.WorkspaceValidityError(message);
 }
 function detectAndSetInvalidProjectGlobValues(map, sourceName, desiredImplicitDeps, projectConfigurations, projects) {
     const invalidProjectsOrGlobs = desiredImplicitDeps.filter((implicit) => {

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

@@ -27,6 +27,11 @@ interface YamlReadOptions {
      * Compatibility with JSON.parse behaviour. If true, then duplicate keys in a mapping will override values rather than throwing an error.
      */
     json?: boolean;
+    /**
+     * Resolves only the tags every YAML parser must support, so every scalar stays
+     * a string instead of `true` or `12`.
+     */
+    failsafe?: boolean;
 }
 /**
  * Reads a YAML file and returns the object the YAML content represents.

package/dist/src/utils/fileutils.js

@@ -41,8 +41,13 @@ function readJsonFile(path, options) {
  */
 function readYamlFile(path, options) {
     const content = (0, node_fs_1.readFileSync)(path, 'utf-8');
-    const { load } = require('@zkochan/js-yaml');
-    return load(content, { ...options, filename: path });
+    const { load, FAILSAFE_SCHEMA } = require('@zkochan/js-yaml');
+    const { failsafe, ...loadOptions } = options ?? {};
+    return load(content, {
+        ...loadOptions,
+        ...(failsafe ? { schema: FAILSAFE_SCHEMA } : {}),
+        filename: path,
+    });
 }
 /**
  * Serializes the given data to JSON and writes it to a file.

package/dist/src/utils/git-worktrees.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Roots of the git linked worktrees that live inside `workspaceRoot`,
+ * relative to it and separator-normalized.
+ *
+ * Reads git's own registry rather than probing the workspace, so it costs one
+ * `readdir` plus a small file per worktree. Worktrees outside the workspace
+ * are dropped - nothing walks them. Submodules use the same gitfile mechanism
+ * but register under `<git-dir>/modules`, so they never appear here.
+ */
+export declare function nestedWorktreeRoots(workspaceRoot: string): string[];
+/**
+ * Whether `path` sits inside `root`, comparing whole path segments so that
+ * `wt-other` is not read as living inside `wt`.
+ */
+export declare function isInside(path: string, root: string): boolean;
+/** Advice for duplicate project names that come from nested git worktrees. */
+export interface WorktreeConflictAdvice {
+    /** Paths to add to `.gitignore`. */
+    ignoreTargets: string[];
+    /**
+     * Whether ignoring them settles every duplicate. When false the caller still
+     * owes the reader the ordinary advice for the ones left over.
+     */
+    explainsAllConflicts: boolean;
+}
+/**
+ * What to tell someone whose duplicate project names come from git worktrees
+ * nested in the workspace, or null when none of them do.
+ */
+export declare function analyzeWorktreeConflicts(workspaceRoot: string, conflicts: Map<string, string[]>): WorktreeConflictAdvice | null;

package/dist/src/utils/git-worktrees.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestedWorktreeRoots = nestedWorktreeRoots;
+exports.isInside = isInside;
+exports.analyzeWorktreeConflicts = analyzeWorktreeConflicts;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const GITDIR_PREFIX = 'gitdir:';
+function readRecordedPath(file, base) {
+    let contents;
+    try {
+        contents = (0, node_fs_1.readFileSync)(file, 'utf-8').trim();
+    }
+    catch {
+        return null;
+    }
+    const raw = contents.startsWith(GITDIR_PREFIX)
+        ? contents.slice(GITDIR_PREFIX.length).trim()
+        : contents;
+    return raw ? (0, node_path_1.resolve)(base, raw) : null;
+}
+function isDirectory(path) {
+    try {
+        return (0, node_fs_1.statSync)(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The nearest directory at or above `from` holding a `.git`, or null when
+ * there is no repository above it.
+ *
+ * The workspace root and the repository root are often the same directory, but
+ * a workspace nested in a larger repo is ordinary - and its worktrees are
+ * registered against the repository, not against the workspace.
+ */
+function findGitRoot(from) {
+    let current = (0, node_path_1.resolve)(from);
+    while (!(0, node_fs_1.existsSync)((0, node_path_1.join)(current, '.git'))) {
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+    return current;
+}
+/**
+ * `<git-dir>/worktrees`, where git registers every linked worktree of the
+ * repository `workspaceRoot` belongs to - found by walking up, since the
+ * workspace need not be the repository root. Null when there is no `.git`, or
+ * when it is a gitfile that names nothing. The registry itself is not checked -
+ * reading it is what tells us whether anything is registered.
+ */
+function worktreeRegistry(workspaceRoot) {
+    const gitRoot = findGitRoot(workspaceRoot);
+    if (!gitRoot) {
+        return null;
+    }
+    const dotGit = (0, node_path_1.join)(gitRoot, '.git');
+    let gitDir;
+    try {
+        gitDir = (0, node_fs_1.statSync)(dotGit).isDirectory()
+            ? dotGit
+            : readRecordedPath(dotGit, gitRoot);
+    }
+    catch {
+        return null;
+    }
+    if (!gitDir) {
+        return null;
+    }
+    // Running from inside a linked worktree lands on
+    // `<main>/.git/worktrees/<name>`, whose `commondir` names the real git dir.
+    // Ignored unless it names a directory that exists. That is a sanity check
+    // on a path out of a file we did not write, not a bound on where it may
+    // point - it can still name any directory on the machine.
+    const commonDir = readRecordedPath((0, node_path_1.join)(gitDir, 'commondir'), gitDir);
+    return (0, node_path_1.join)(commonDir && isDirectory(commonDir) ? commonDir : gitDir, 'worktrees');
+}
+/**
+ * Roots of the git linked worktrees that live inside `workspaceRoot`,
+ * relative to it and separator-normalized.
+ *
+ * Reads git's own registry rather than probing the workspace, so it costs one
+ * `readdir` plus a small file per worktree. Worktrees outside the workspace
+ * are dropped - nothing walks them. Submodules use the same gitfile mechanism
+ * but register under `<git-dir>/modules`, so they never appear here.
+ */
+function nestedWorktreeRoots(workspaceRoot) {
+    const registry = worktreeRegistry(workspaceRoot);
+    if (!registry) {
+        return [];
+    }
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(registry);
+    }
+    catch {
+        return [];
+    }
+    const roots = [];
+    for (const entry of entries) {
+        // Points at the worktree's own `.git` gitfile, so its parent is the root.
+        const gitfile = readRecordedPath((0, node_path_1.join)(registry, entry, 'gitdir'), (0, node_path_1.join)(registry, entry));
+        if (!gitfile || !(0, node_fs_1.existsSync)(gitfile)) {
+            continue;
+        }
+        const root = (0, node_path_1.relative)(workspaceRoot, (0, node_path_1.dirname)(gitfile));
+        // Neither the workspace itself nor anything outside it is a nested
+        // worktree Nx would walk into. Compared by whole segments, because `..` is
+        // a traversal and `..hidden` is an ordinary directory name; and by
+        // absoluteness, because `relative` across Windows drives returns its
+        // second argument, which is outside by definition and carries no `..`.
+        if (!root || (0, node_path_1.isAbsolute)(root) || root.split(node_path_1.sep)[0] === '..') {
+            continue;
+        }
+        roots.push(root.split(node_path_1.sep).join('/'));
+    }
+    return roots;
+}
+/**
+ * Whether `path` sits inside `root`, comparing whole path segments so that
+ * `wt-other` is not read as living inside `wt`.
+ */
+function isInside(path, root) {
+    return path === root || path.startsWith(`${root}/`);
+}
+/**
+ * What to tell someone whose duplicate project names come from git worktrees
+ * nested in the workspace, or null when none of them do.
+ */
+function analyzeWorktreeConflicts(workspaceRoot, conflicts) {
+    const worktrees = nestedWorktreeRoots(workspaceRoot);
+    if (!worktrees.length) {
+        return null;
+    }
+    const offending = [];
+    let explainsAllConflicts = true;
+    for (const roots of conflicts.values()) {
+        const fromWorktrees = worktrees.filter((worktree) => roots.some((root) => isInside(root, worktree)));
+        // What would still be defined twice once the worktrees are out of the way.
+        const remaining = roots.filter((root) => !worktrees.some((worktree) => isInside(root, worktree)));
+        // Worth naming whenever a worktree is involved, even if ignoring it
+        // doesn't settle the whole conflict.
+        for (const worktree of fromWorktrees) {
+            if (!offending.includes(worktree)) {
+                offending.push(worktree);
+            }
+        }
+        if (!fromWorktrees.length || remaining.length > 1) {
+            explainsAllConflicts = false;
+        }
+    }
+    if (!offending.length) {
+        return null;
+    }
+    return {
+        ignoreTargets: ignoreTargetsFor(workspaceRoot, offending, worktrees),
+        explainsAllConflicts,
+    };
+}
+/**
+ * The worktree roots themselves, or the one directory holding them.
+ *
+ * Collapsing to the directory is only worth anything when it saves lines, and
+ * only safe when it holds nothing else. With a single worktree it saves
+ * nothing and risks everything: a lone worktree in `apps/` would have us name
+ * `apps/`, which holds only that worktree today and is where the reader will
+ * put projects tomorrow.
+ */
+function ignoreTargetsFor(workspaceRoot, offending, worktrees) {
+    if (offending.length < 2) {
+        return offending.map(anchored);
+    }
+    const parent = commonParent(offending);
+    return (parent && holdsOnlyWorktrees(workspaceRoot, parent, worktrees)
+        ? [parent]
+        : offending).map(anchored);
+}
+/**
+ * A gitignore pattern rooted at the workspace rather than matched anywhere.
+ *
+ * Without the leading slash a single-segment path like `wt1` is a name, not a
+ * location - it would ignore every `wt1` at any depth. Applied to all of them
+ * so the emitted line reads the same way wherever it came from.
+ */
+function anchored(root) {
+    return `/${root}`;
+}
+/**
+ * The directory every one of `roots` sits directly inside, or null when they
+ * don't share one - including when it would be the workspace root, which is
+ * never something to ignore.
+ */
+function commonParent(roots) {
+    const parents = new Set(roots.map((root) => root.split('/').slice(0, -1).join('/')));
+    const [parent] = parents;
+    return parents.size === 1 && parent ? parent : null;
+}
+function holdsOnlyWorktrees(workspaceRoot, directory, worktrees) {
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)((0, node_path_1.join)(workspaceRoot, directory));
+    }
+    catch {
+        return false;
+    }
+    return (entries.length > 0 &&
+        entries.every((entry) => worktrees.includes(`${directory}/${entry}`)));
+}

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

@@ -1,7 +1,134 @@
 import ignore = require('ignore');
 import { Tree } from '../generators/tree';
 export declare function getIgnoreObject(root?: string): ReturnType<typeof ignore>;
-export declare function getIgnoreObjectForTree(tree: Tree): ignore.Ignore;
+/** One directory's ignore files, and the directory its patterns are rooted at. */
+export type ScopedIgnoreMatcher = {
+    /** Workspace-relative POSIX directory, `''` for the workspace root. */
+    dir: string;
+    /** How they relate is decided at build time - see `merge`. */
+    matchers: ReturnType<typeof ignore>[];
+};
+/**
+ * Resolves the ignore files that apply to a directory: its own and every one
+ * above it, up to the workspace root.
+ *
+ * Ignore files cascade - a `.gitignore` covers its own directory and below, and
+ * its patterns are relative to *itself*, not to the workspace root. Reading only
+ * the root file, which is what `getIgnoreObject` does, silently misses every
+ * nested one.
+ *
+ * A directory's answer is its own files plus its parent's, so every directory on
+ * the way up is memoized rather than only the one asked for: sibling leaves
+ * share the whole trunk, and a later walk stops at the first directory already
+ * known.
+ *
+ * `read` decides where the files come from - `tree.read` for a generator, disk
+ * for a caller with no tree - and returns an empty string or null when there is
+ * no such file. Paths handed to it are workspace-relative POSIX.
+ *
+ * `merge` decides how the files *within one directory* relate, and the two
+ * consumers genuinely need different rules:
+ *
+ * - `false` is prettier's: one matcher per file, any of them excluding wins, and
+ *   a negation counts only if none excluded. `createIsIgnoredFunction` builds an
+ *   ignorer per `--ignore-path` and ORs them, so a `!x` in `.prettierignore`
+ *   cannot re-include an `x` that `.gitignore` excluded.
+ * - `true` is git's and the native walker's: all files in one matcher, so
+ *   `.nxignore`'s `!x` removes `.gitignore`'s exclusion of `x` outright. It has
+ *   to be a merge rather than a precedence check between separate matchers,
+ *   because a lone `!x` in its own matcher reports an opinion on `x/` but *none*
+ *   on `x/a.ts` (measured), so the exclusion would still reach the children.
+ *   The merge only removes the exclusion within that one directory - a negation
+ *   in a nested file still loses to an ancestor's exclusion.
+ *
+ * When `merge` is true, `filenames` order matters: they go into one matcher in
+ * order and the last matching pattern decides, so list them lowest-authority
+ * first.
+ */
+export declare function createIgnoreChainResolver(read: (path: string) => string | null | undefined, filenames: string[], merge: boolean): (dir: string) => ScopedIgnoreMatcher[];
+/**
+ * True when the file is ignored, resolving the chain nearest file first.
+ *
+ * Each matcher is tested against the path relative to its own directory, which
+ * is what makes a nested pattern like `/build` mean that directory's `build`
+ * rather than the workspace's.
+ *
+ * Nearest directory with an *opinion* wins, not the first match: a nested
+ * `!keep.log` must override the root's `*.log`, which is git's rule for files.
+ * A nested negation of a *directory* does not reach its children - see the
+ * `merge` note on `createIgnoreChainResolver`.
+ *
+ * How the files of one directory relate is decided when the chain is built - see
+ * that same note. Here they are simply the entry's matchers: any one excluding
+ * wins, and a negation counts only if none excluded.
+ *
+ * Two preconditions, both satisfied by a pruning walk and neither enforced:
+ *
+ * - `filePath` is workspace-relative POSIX and must sit under every `dir` in the
+ *   chain, which holds when the chain came from that file's own directory.
+ * - No ancestor directory of `filePath` may itself be ignored. git refuses to
+ *   re-include a file inside an excluded directory, and this does not implement
+ *   that rule: asked directly about `dist/keep.ts` with a root `dist/` and a
+ *   nested `dist/.gitignore` holding `!keep.ts`, it answers "not ignored" where
+ *   git says ignored (measured). `visitNotIgnoredFiles` never asks, because it
+ *   prunes `dist/` before descending - which is what makes its answers match
+ *   git, and why that pruning is load-bearing for correctness rather than speed.
+ */
+export declare function isIgnoredByChain(chain: ScopedIgnoreMatcher[], filePath: string): boolean;
+/**
+ * Directories that should never be walked, whatever the workspace's own ignore
+ * files say - `node_modules`, `.git`, the nx caches.
+ *
+ * The list comes from the native walker rather than a second copy here, so a
+ * filesystem walk and a tree walk cannot drift apart.
+ *
+ * Checked ahead of the cascading chain rather than folded into it: these are not
+ * re-includable, and as ordinary patterns a nested negation could resurrect
+ * `node_modules`.
+ */
+export declare function isAlwaysIgnored(path: string): boolean;
+/**
+ * The chain bound to a tree, as predicates over workspace-relative POSIX paths.
+ *
+ * Files and directories are asked separately because the answers differ: a
+ * pattern is only directory-only if it ends in a slash, and `ignore` will not
+ * match `dist/` against the path `dist`. Callers must not have to know that, so
+ * the slash is appended inside and never leaves this module.
+ */
+export type TreeIgnoreChecker = {
+    isIgnoredFile: (path: string) => boolean;
+    isIgnoredDirectory: (path: string) => boolean;
+};
+/**
+ * What git ignores, which is also what the native walker ignores.
+ *
+ * `.nxignore` outranks `.gitignore` - `walker.rs` registers it with
+ * `add_custom_ignore_filename` - which a merge with `.nxignore` last reproduces.
+ * git itself does not read it.
+ *
+ * Reads from the tree rather than disk because a generator can create or amend
+ * an ignore file in the same run, which would leave the on-disk copy stale.
+ */
+export declare function createGitIgnoreChecker(tree: Tree): TreeIgnoreChecker;
+/**
+ * What prettier ignores: the workspace root only, and one ignorer per
+ * `--ignore-path` ORed rather than merged (both measured), so a `!` in
+ * `.prettierignore` cannot re-include what `.gitignore` excluded. That is the
+ * CLI `nx format:check` shells out to.
+ *
+ * Not an exact match for that command: `isAlwaysIgnored` is wider than
+ * prettier's built-ins, and `format.ts` filters its own patterns through
+ * `.nxignore`, which this does not read.
+ *
+ * Reads from the tree rather than disk, as above.
+ */
+export declare function createPrettierIgnoreChecker(tree: Tree): TreeIgnoreChecker;
+/**
+ * `path.dirname` for the workspace-relative POSIX paths the chain is keyed by,
+ * except that the workspace root is `''` rather than `.` - that is the key
+ * `createIgnoreChainResolver` terminates on.
+ */
+export declare function posixDirname(relativePath: string): string;
 /**
  * Adds an entry to a .gitignore file if it's not already covered by existing patterns.
  * Creates the file if it doesn't exist.

package/dist/src/utils/ignore.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIgnoreObject = getIgnoreObject;
-exports.getIgnoreObjectForTree = getIgnoreObjectForTree;
+exports.createIgnoreChainResolver = createIgnoreChainResolver;
+exports.isIgnoredByChain = isIgnoredByChain;
+exports.isAlwaysIgnored = isAlwaysIgnored;
+exports.createGitIgnoreChecker = createGitIgnoreChecker;
+exports.createPrettierIgnoreChecker = createPrettierIgnoreChecker;
+exports.posixDirname = posixDirname;
 exports.addEntryToGitIgnore = addEntryToGitIgnore;
 const ignore = require("ignore");
+const index_1 = require("../native/index");
 const fileutils_1 = require("./fileutils");
 const workspace_root_1 = require("./workspace-root");
 function getIgnoreObject(root = workspace_root_1.workspaceRoot) {
@@ -12,18 +18,182 @@ function getIgnoreObject(root = workspace_root_1.workspaceRoot) {
     ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.nxignore`));
     return ig;
 }
-function getIgnoreObjectForTree(tree) {
-    let ig;
-    if (tree.exists('.gitignore')) {
-        ig = ignore();
-        ig.add('.git');
-        ig.add(tree.read('.gitignore', 'utf-8'));
-    }
-    if (tree.exists('.nxignore')) {
-        ig ??= ignore();
-        ig.add(tree.read('.nxignore', 'utf-8'));
+/**
+ * Resolves the ignore files that apply to a directory: its own and every one
+ * above it, up to the workspace root.
+ *
+ * Ignore files cascade - a `.gitignore` covers its own directory and below, and
+ * its patterns are relative to *itself*, not to the workspace root. Reading only
+ * the root file, which is what `getIgnoreObject` does, silently misses every
+ * nested one.
+ *
+ * A directory's answer is its own files plus its parent's, so every directory on
+ * the way up is memoized rather than only the one asked for: sibling leaves
+ * share the whole trunk, and a later walk stops at the first directory already
+ * known.
+ *
+ * `read` decides where the files come from - `tree.read` for a generator, disk
+ * for a caller with no tree - and returns an empty string or null when there is
+ * no such file. Paths handed to it are workspace-relative POSIX.
+ *
+ * `merge` decides how the files *within one directory* relate, and the two
+ * consumers genuinely need different rules:
+ *
+ * - `false` is prettier's: one matcher per file, any of them excluding wins, and
+ *   a negation counts only if none excluded. `createIsIgnoredFunction` builds an
+ *   ignorer per `--ignore-path` and ORs them, so a `!x` in `.prettierignore`
+ *   cannot re-include an `x` that `.gitignore` excluded.
+ * - `true` is git's and the native walker's: all files in one matcher, so
+ *   `.nxignore`'s `!x` removes `.gitignore`'s exclusion of `x` outright. It has
+ *   to be a merge rather than a precedence check between separate matchers,
+ *   because a lone `!x` in its own matcher reports an opinion on `x/` but *none*
+ *   on `x/a.ts` (measured), so the exclusion would still reach the children.
+ *   The merge only removes the exclusion within that one directory - a negation
+ *   in a nested file still loses to an ancestor's exclusion.
+ *
+ * When `merge` is true, `filenames` order matters: they go into one matcher in
+ * order and the last matching pattern decides, so list them lowest-authority
+ * first.
+ */
+function createIgnoreChainResolver(read, filenames, merge) {
+    const cache = new Map();
+    const resolve = (dir) => {
+        const cached = cache.get(dir);
+        if (cached) {
+            return cached;
+        }
+        const contents = filenames
+            .map((name) => read(dir ? `${dir}/${name}` : name))
+            .filter((c) => !!c);
+        const matchers = merge
+            ? contents.length > 0
+                ? [contents.reduce((m, c) => m.add(c), ignore())]
+                : []
+            : contents.map((c) => ignore().add(c));
+        const inherited = dir === '' ? [] : resolve(posixDirname(dir));
+        const chain = matchers.length > 0 ? [{ dir, matchers }, ...inherited] : inherited;
+        cache.set(dir, chain);
+        return chain;
+    };
+    return resolve;
+}
+/**
+ * True when the file is ignored, resolving the chain nearest file first.
+ *
+ * Each matcher is tested against the path relative to its own directory, which
+ * is what makes a nested pattern like `/build` mean that directory's `build`
+ * rather than the workspace's.
+ *
+ * Nearest directory with an *opinion* wins, not the first match: a nested
+ * `!keep.log` must override the root's `*.log`, which is git's rule for files.
+ * A nested negation of a *directory* does not reach its children - see the
+ * `merge` note on `createIgnoreChainResolver`.
+ *
+ * How the files of one directory relate is decided when the chain is built - see
+ * that same note. Here they are simply the entry's matchers: any one excluding
+ * wins, and a negation counts only if none excluded.
+ *
+ * Two preconditions, both satisfied by a pruning walk and neither enforced:
+ *
+ * - `filePath` is workspace-relative POSIX and must sit under every `dir` in the
+ *   chain, which holds when the chain came from that file's own directory.
+ * - No ancestor directory of `filePath` may itself be ignored. git refuses to
+ *   re-include a file inside an excluded directory, and this does not implement
+ *   that rule: asked directly about `dist/keep.ts` with a root `dist/` and a
+ *   nested `dist/.gitignore` holding `!keep.ts`, it answers "not ignored" where
+ *   git says ignored (measured). `visitNotIgnoredFiles` never asks, because it
+ *   prunes `dist/` before descending - which is what makes its answers match
+ *   git, and why that pruning is load-bearing for correctness rather than speed.
+ */
+function isIgnoredByChain(chain, filePath) {
+    for (const { dir, matchers } of chain) {
+        const relative = dir === '' ? filePath : filePath.slice(dir.length + 1);
+        let unignored = false;
+        for (const matcher of matchers) {
+            const result = matcher.test(relative);
+            if (result.ignored) {
+                return true;
+            }
+            unignored ||= result.unignored;
+        }
+        if (unignored) {
+            return false;
+        }
     }
-    return ig;
+    return false;
+}
+let alwaysIgnored;
+/**
+ * Directories that should never be walked, whatever the workspace's own ignore
+ * files say - `node_modules`, `.git`, the nx caches.
+ *
+ * The list comes from the native walker rather than a second copy here, so a
+ * filesystem walk and a tree walk cannot drift apart.
+ *
+ * Checked ahead of the cascading chain rather than folded into it: these are not
+ * re-includable, and as ordinary patterns a nested negation could resurrect
+ * `node_modules`.
+ */
+function isAlwaysIgnored(path) {
+    alwaysIgnored ??= ignore().add((0, index_1.getHardcodedIgnorePatterns)());
+    return alwaysIgnored.ignores(path);
+}
+/**
+ * What git ignores, which is also what the native walker ignores.
+ *
+ * `.nxignore` outranks `.gitignore` - `walker.rs` registers it with
+ * `add_custom_ignore_filename` - which a merge with `.nxignore` last reproduces.
+ * git itself does not read it.
+ *
+ * Reads from the tree rather than disk because a generator can create or amend
+ * an ignore file in the same run, which would leave the on-disk copy stale.
+ */
+function createGitIgnoreChecker(tree) {
+    return createTreeIgnoreChecker(tree, {
+        filenames: ['.gitignore', '.nxignore'],
+        cascade: true,
+        merge: true,
+    });
+}
+/**
+ * What prettier ignores: the workspace root only, and one ignorer per
+ * `--ignore-path` ORed rather than merged (both measured), so a `!` in
+ * `.prettierignore` cannot re-include what `.gitignore` excluded. That is the
+ * CLI `nx format:check` shells out to.
+ *
+ * Not an exact match for that command: `isAlwaysIgnored` is wider than
+ * prettier's built-ins, and `format.ts` filters its own patterns through
+ * `.nxignore`, which this does not read.
+ *
+ * Reads from the tree rather than disk, as above.
+ */
+function createPrettierIgnoreChecker(tree) {
+    return createTreeIgnoreChecker(tree, {
+        filenames: ['.gitignore', '.prettierignore'],
+        cascade: false,
+        merge: false,
+    });
+}
+function createTreeIgnoreChecker(tree, { filenames, cascade, merge }) {
+    const resolve = createIgnoreChainResolver((path) => tree.read(path, 'utf-8'), filenames, merge);
+    // `probe` may carry a trailing slash; `path` never does. The chain is keyed by
+    // real directories, and `posixDirname('dist/')` is `'dist'` rather than the
+    // parent, so the lookup always uses the slash-less form.
+    const check = (path, probe) => isAlwaysIgnored(probe) ||
+        isIgnoredByChain(resolve(cascade ? posixDirname(path) : ''), probe);
+    return {
+        isIgnoredFile: (path) => check(path, path),
+        isIgnoredDirectory: (path) => check(path, `${path}/`),
+    };
+}
+/**
+ * `path.dirname` for the workspace-relative POSIX paths the chain is keyed by,
+ * except that the workspace root is `''` rather than `.` - that is the key
+ * `createIgnoreChainResolver` terminates on.
+ */
+function posixDirname(relativePath) {
+    const separator = relativePath.lastIndexOf('/');
+    return separator === -1 ? '' : relativePath.slice(0, separator);
 }
 /**
  * Adds an entry to a .gitignore file if it's not already covered by existing patterns.

package/dist/src/utils/long-running-target.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Target names the pre-23 `longRunningTask` guard excluded from caching. Shared
+ * between that guard and the deprecated target-name cache fallback so the two
+ * cannot drift apart.
+ *
+ * The copy in `migrations/update-23-2-0/set-cache-on-executor-target-defaults.ts`
+ * deliberately does not use this: a migration's decision has to freeze at the
+ * semantics it shipped with.
+ */
+export declare function isLongRunningTargetName(targetName: string): boolean;

package/dist/src/utils/long-running-target.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLongRunningTargetName = isLongRunningTargetName;
+/**
+ * Target names the pre-23 `longRunningTask` guard excluded from caching. Shared
+ * between that guard and the deprecated target-name cache fallback so the two
+ * cannot drift apart.
+ *
+ * The copy in `migrations/update-23-2-0/set-cache-on-executor-target-defaults.ts`
+ * deliberately does not use this: a migration's decision has to freeze at the
+ * semantics it shipped with.
+ */
+function isLongRunningTargetName(targetName) {
+    return (targetName.endsWith(':watch') ||
+        targetName.endsWith('-watch') ||
+        targetName === 'serve' ||
+        targetName === 'dev' ||
+        targetName === 'start');
+}