nx 23.2.0-beta.5 → 23.2.0-beta.7

package/dist/src/utils/child-process.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PseudoTtyProcess = void 0;
 exports.getRunNxBaseCommand = getRunNxBaseCommand;
+exports.getNxBin = getNxBin;
+exports.readInstalledNxBin = readInstalledNxBin;
+exports.runNxArgvSync = runNxArgvSync;
 exports.runNxSync = runNxSync;
 exports.runNxAsync = runNxAsync;
 const child_process_1 = require("child_process");
@@ -10,11 +13,14 @@ const path_1 = require("path");
 const package_manager_1 = require("./package-manager");
 const workspace_root_1 = require("./workspace-root");
 const exit_codes_1 = require("./exit-codes");
+const fileutils_1 = require("./fileutils");
+const shell_quoting_1 = require("./shell-quoting");
 function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
     if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
         if (!packageManagerCommand) {
             // `readLocalNxVersion` (command-line/migrate/migrate.ts) mirrors this
-            // selector to predict which nx the spawn will run; keep the two in sync.
+            // selector to predict which nx a spawn will run, for the workspaces
+            // `getNxBin` declines to resolve; keep the two in sync.
             const pm = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
             packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm, workspace_root_1.workspaceRoot);
         }
@@ -30,6 +36,101 @@ function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
         }
     }
 }
+/**
+ * Locate an nx entry point to spawn for the workspace at `root`, so a caller
+ * can run it directly instead of going through a shell. `findInstalledNxBin`
+ * decides which one.
+ *
+ * Null means nothing may be spawned directly, leaving the caller to fall back
+ * to `getRunNxBaseCommand`. Null is therefore always safe: it costs the
+ * argument fidelity a direct spawn buys, never the ability to run.
+ */
+function getNxBin(root = workspace_root_1.workspaceRoot) {
+    // A workspace with no root package.json runs nx through the `./nx` wrapper,
+    // which reinstalls `.nx/installation` whenever it drifts from nx.json's
+    // `installation.version`. Spawning the resolved entry point would skip that
+    // sync, and a migration is precisely when the version changes.
+    if (!(0, fs_1.existsSync)((0, path_1.join)(root, 'package.json'))) {
+        return null;
+    }
+    return findInstalledNxBin(root);
+}
+/**
+ * The entry point the nx installed directly under `dir` names, with no ascent
+ * to `dir`'s ancestors. For an installation that declares nx itself, such as
+ * the temp CLI `nx migrate` builds, an ancestor's nx is never the right answer.
+ */
+function readInstalledNxBin(dir) {
+    const packageDir = (0, path_1.join)(dir, 'node_modules', 'nx');
+    const manifest = (0, path_1.join)(packageDir, 'package.json');
+    if (!(0, fs_1.existsSync)(manifest)) {
+        return null;
+    }
+    let bin;
+    try {
+        ({ bin } = (0, fileutils_1.readJsonFile)(manifest));
+    }
+    catch {
+        return null;
+    }
+    // npm accepts both the single-entry shorthand and the map form.
+    const entry = typeof bin === 'string' ? bin : bin?.nx;
+    return typeof entry === 'string' ? (0, path_1.join)(packageDir, entry) : null;
+}
+// Ascend to the nearest installed nx and take the entry point its `bin` field
+// names, which is the file a package manager links into `node_modules/.bin`.
+// Deliberately npx-shaped: npx and bun ascend unconditionally while pnpm and
+// yarn stop at an outer workspace, so this can name an nx those two would
+// decline to run.
+//
+// Deliberately not a resolver. Resolvers answer from NODE_PATH once their
+// explicit paths miss, and `nxCliPath` (command-line/migrate/migrate.ts) points
+// NODE_PATH at the temp installation before spawning it; they also answer
+// through package self-reference, which hands back the running nx whatever
+// `paths` they are given. Either one lets the temp installation hand off to
+// itself, which for `--run-migrations` re-enters the same hand-off and respawns
+// without end.
+function findInstalledNxBin(root) {
+    for (let dir = root;; dir = (0, path_1.dirname)(dir)) {
+        // The nearest install wins, so an unusable manifest there ends the search
+        // rather than deferring to an ancestor.
+        if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'node_modules', 'nx', 'package.json'))) {
+            return readInstalledNxBin(dir);
+        }
+        if (dir === (0, path_1.dirname)(dir)) {
+            return null;
+        }
+    }
+}
+/**
+ * Run a nx command, passing the arguments through as an argv array.
+ *
+ * When `getNxBin` names an entry point, the child is spawned directly with no
+ * shell in between, so every argument reaches the child exactly as provided:
+ * shell metacharacters (`(`, `%`, `^`, spaces, quotes) are data, not syntax.
+ * Otherwise falls back to the package-manager + shell path, where every
+ * argument goes through `quoteShellArg` and the Windows limits it documents
+ * apply.
+ */
+function runNxArgvSync(argv, options) {
+    let { nxBin, ...spawnOptions } = options ?? {};
+    spawnOptions.cwd ??= process.cwd();
+    spawnOptions.windowsHide ??= true;
+    nxBin ??= getNxBin((0, workspace_root_1.workspaceRootInner)(spawnOptions.cwd, null) ?? workspace_root_1.workspaceRoot);
+    if (!nxBin) {
+        runNxSync(argv.map(shell_quoting_1.quoteShellArg).join(' '), spawnOptions);
+        return;
+    }
+    const result = (0, child_process_1.spawnSync)(process.execPath, [nxBin, ...argv], spawnOptions);
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const error = new Error(`Command failed: nx ${argv.join(' ')} (exit code ${result.status})`);
+        error.status = result.status ?? 1;
+        throw error;
+    }
+}
 function runNxSync(cmd, options) {
     let { packageManagerCommand, ...execSyncOptions } = options ?? {};
     execSyncOptions.cwd ??= process.cwd();

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/nx-tmp-dir.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Stable root for Nx runtime artifacts that need an OS tmp location. On POSIX a
+ * literal `/tmp`, not `os.tmpdir()`, which honours `$TMPDIR` — per-user on
+ * macOS, rewritten by sandboxes, stripped from the daemon env, so client and
+ * daemon would disagree. Windows has no `/tmp`, and `%TMP%` is already per-user
+ * and stable, so it keeps `os.tmpdir()`.
+ *
+ * Consumed by the native binding loader, so keep this file limited to local
+ * helpers that themselves use Node builtins only.
+ */
+export declare const NX_TMP_DIR: string;
+/**
+ * Owner-only runtime root for the current user. No user segment on Windows —
+ * `%TMP%` is already per-account, and the segment would only cost path length.
+ */
+export declare const NX_USER_TMP_DIR: string;
+/** Runtime root under the user's home, used when the shared container cannot be established. */
+export declare const NX_HOME_TMP_DIR: string;

package/dist/src/utils/nx-tmp-dir.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_HOME_TMP_DIR = exports.NX_USER_TMP_DIR = exports.NX_TMP_DIR = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const owned_private_dir_1 = require("./owned-private-dir");
+/**
+ * Stable root for Nx runtime artifacts that need an OS tmp location. On POSIX a
+ * literal `/tmp`, not `os.tmpdir()`, which honours `$TMPDIR` — per-user on
+ * macOS, rewritten by sandboxes, stripped from the daemon env, so client and
+ * daemon would disagree. Windows has no `/tmp`, and `%TMP%` is already per-user
+ * and stable, so it keeps `os.tmpdir()`.
+ *
+ * Consumed by the native binding loader, so keep this file limited to local
+ * helpers that themselves use Node builtins only.
+ */
+exports.NX_TMP_DIR = (0, node_os_1.platform)() === 'win32' ? (0, node_path_1.join)((0, node_os_1.tmpdir)(), '.nx') : '/tmp/.nx';
+/**
+ * Owner-only runtime root for the current user. No user segment on Windows —
+ * `%TMP%` is already per-account, and the segment would only cost path length.
+ */
+exports.NX_USER_TMP_DIR = (0, node_os_1.platform)() === 'win32' ? exports.NX_TMP_DIR : (0, node_path_1.join)(exports.NX_TMP_DIR, (0, owned_private_dir_1.getUserSegment)());
+/** Runtime root under the user's home, used when the shared container cannot be established. */
+exports.NX_HOME_TMP_DIR = resolveHomeTmpDir();
+/**
+ * Absolute, not merely non-empty: a relative `$HOME` would make `join` return
+ * `.nx`, putting sockets under the cwd and aiming `removeSocketDir`'s recursive
+ * delete at it. A rootless container has no `$HOME` and no passwd entry, so
+ * `homedir()` throws or returns empty — caught here because this runs at module
+ * scope and the native binding loader imports this file.
+ */
+function resolveHomeTmpDir() {
+    try {
+        const home = (0, node_os_1.homedir)();
+        return home && (0, node_path_1.isAbsolute)(home) ? (0, node_path_1.join)(home, '.nx') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/utils/owned-private-dir.d.ts

@@ -0,0 +1,132 @@
+declare const safeSharedRootBrand: unique symbol;
+declare const sharedRootEstablishedBrand: unique symbol;
+declare const ownedRealDirBrand: unique symbol;
+declare const ownedPrivateDirBrand: unique symbol;
+/** Verified safe to keep an owner-only directory under. Not created. */
+export type SafeSharedRoot = string & {
+    readonly [safeSharedRootBrand]: true;
+};
+/** Created if absent, then verified safe as above. */
+export type EstablishedSharedRoot = string & {
+    readonly [sharedRootEstablishedBrand]: true;
+};
+/** An existing real directory owned by us. Mode is *not* checked. */
+export type OwnedRealDir = string & {
+    readonly [ownedRealDirBrand]: true;
+};
+/**
+ * POSIX: created if absent, owned by us, and carrying no group or other bits —
+ * re-locked first if it was looser. The mode is checked on whichever branch
+ * produced it, so the brand does not depend on who created the directory.
+ *
+ * Windows: only *is a real directory*. `getuid` is unavailable there, so
+ * neither ownership nor mode is checked; `%TMP%` is already per-account.
+ */
+export type OwnedPrivateDir = string & {
+    readonly [ownedPrivateDirBrand]: true;
+};
+/** Why a guard refused a directory. Data, not a sentence: `remedyFor` decides on it. */
+export type DirRefusal = {
+    kind: 'not-created';
+    dir: string;
+    code?: string;
+} | {
+    kind: 'not-inspectable';
+    dir: string;
+    code?: string;
+} | {
+    kind: 'not-a-directory';
+    dir: string;
+    symlink?: true;
+} | {
+    kind: 'foreign-owner';
+    dir: string;
+    uid: number;
+} | {
+    kind: 'foreign-shared-container';
+    dir: string;
+    uid: number;
+} | {
+    kind: 'not-tightenable';
+    dir: string;
+    mode: number;
+} | {
+    kind: 'peer-writable-not-sticky';
+    dir: string;
+    mode: number;
+};
+/** A guard's verdict. */
+export type GuardResult<T> = {
+    status: 'ok';
+    path: T;
+} | {
+    status: 'refused';
+    refusal: DirRefusal;
+};
+/** The user-facing sentence for a refusal. The only place wording is decided. */
+export declare function describeRefusal(r: DirRefusal): string;
+/** What the user can do about a refusal, or `undefined` when there is nothing. */
+export declare function remedyFor(r: DirRefusal): string | undefined;
+/** One refusal as an `Error`, so several can travel in an `AggregateError`. */
+export declare class DirectoryRefusedError extends Error {
+    readonly refusal: DirRefusal;
+    constructor(refusal: DirRefusal);
+}
+/**
+ * Whether a shared container is safe to keep an owner-only directory under.
+ *
+ * On POSIX, a container writable by other users must be sticky, and it must be
+ * owned by either root or the current user. Windows short-circuits after the
+ * directory test — the OS temp root is already scoped to one account, so there
+ * is no shared level whose ownership could matter.
+ *
+ * Sticky directories still let the directory's own owner rename entries, so a
+ * container owned by another unprivileged user could replace a previously
+ * verified private directory beneath it.
+ */
+export declare function isSafeSharedRoot(dir: string): GuardResult<SafeSharedRoot>;
+/**
+ * Whether other users on this machine can write into `dir`. Gates whether a
+ * refusal message may cite other users, so it must not over-report: `false` on
+ * Windows, where libuv synthesizes `st_mode` from the READONLY attribute and
+ * reports an ordinary per-account directory as `0666`, and `false` on a path
+ * that cannot be inspected.
+ *
+ * `statSync`, not `lstatSync`: the question is about the directory that will be
+ * used, not the link pointing at it. Link modes mislead in both directions —
+ * Linux creates symlinks `0777`, macOS applies the umask. Nothing here decides
+ * whether a path is accepted, so following the link costs nothing the guards
+ * do not already re-check.
+ */
+export declare function isPeerWritable(dir: string): boolean;
+/**
+ * Create a shared container as sticky + world-writable if it does not exist,
+ * and report whether the resulting path is safe for the current user.
+ *
+ * **A container that already exists is never modified — only judged.** Do not
+ * chmod before deciding trust: `CAP_FOWNER` (root's default in Docker and most
+ * CI images) can chmod a directory it does not own, so a peer-owned root would
+ * be widened to `1777` and then refused, and an operator who deliberately
+ * tightened this root would have it re-widened on every `nx` process.
+ */
+export declare function ensureSafeSharedRoot(dir: string): GuardResult<EstablishedSharedRoot>;
+/**
+ * Whether `dir` is an existing real directory owned by us. Unlike
+ * `ensureOwnedPrivateDir` it creates nothing and repairs nothing — for callers
+ * that only want to know whether a path is safe to act on, such as deleting.
+ */
+export declare function isOwnedRealDirectory(dir: string): OwnedRealDir | null;
+/** The path segment separating one user's Nx runtime state from another's. */
+export declare function getUserSegment(): string;
+/**
+ * Ensure `dir` exists, is a real directory owned by us, and carries no group or
+ * other bits at all — read and search alone reach a socket inside it, so 0755 is
+ * re-locked rather than accepted. A `refused` status carries which check said
+ * no — usually `foreign-owner` for a directory another user planted, but also
+ * `not-created`/`not-inspectable` for a filesystem error, `not-a-directory`, or
+ * `not-tightenable` when the re-lock did not land.
+ *
+ * Node builtins only: reached from the native binding loader.
+ */
+export declare function ensureOwnedPrivateDir(dir: string): GuardResult<OwnedPrivateDir>;
+export {};