nx 23.2.0-beta.2 → 23.2.0-beta.3

package/dist/src/utils/catalog/bun-manager.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunCatalogManager = void 0;
+const manager_1 = require("./manager");
+const bun_manager_utils_1 = require("./bun-manager-utils");
+const BUN_CATALOG_FILENAME = 'package.json';
+/**
+ * Bun-specific catalog manager implementation.
+ *
+ * Bun declares catalogs in the root package.json `catalog`/`catalogs` fields,
+ * either at the top level or nested under the object form of `workspaces`.
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
+ */
+class BunCatalogManager {
+    constructor() {
+        this.name = 'bun';
+        this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readBunCatalogDefinitions.
+        this.definitionsByRoot = new Map();
+    }
+    isCatalogReference(version) {
+        return version.startsWith(this.catalogProtocol);
+    }
+    parseCatalogReference(version) {
+        if (!this.isCatalogReference(version)) {
+            return null;
+        }
+        const catalogName = version.substring(this.catalogProtocol.length).trim();
+        // Only an empty/whitespace name selects the default catalog; "default" is
+        // a regular named catalog in bun.
+        const isDefault = !catalogName;
+        return {
+            catalogName: isDefault ? undefined : catalogName,
+            isDefaultCatalog: isDefault,
+        };
+    }
+    getCatalogDefinitionFilePaths() {
+        return [BUN_CATALOG_FILENAME];
+    }
+    getCatalogDefinitions(treeOrRoot) {
+        return (0, bun_manager_utils_1.readBunCatalogDefinitions)(BUN_CATALOG_FILENAME, treeOrRoot, this.definitionsByRoot);
+    }
+    resolveCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            return null;
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            return null;
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            catalogToUse = catalogDefs.catalog;
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+    }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
+    validateCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            throw new Error(`Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`);
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            throw new Error((0, manager_1.formatCatalogError)(`Cannot get Bun catalog definitions. No catalog defined in ${BUN_CATALOG_FILENAME}.`, [
+                `Add a "catalog" or "catalogs" field to ${BUN_CATALOG_FILENAME} in your workspace root`,
+            ]));
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            catalogToUse = catalogDefs.catalog;
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define a default catalog in ${BUN_CATALOG_FILENAME} under the "catalog" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`No default catalog defined in ${BUN_CATALOG_FILENAME}`, suggestions));
+            }
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define the catalog in ${BUN_CATALOG_FILENAME} under the "catalogs" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                if (catalogDefs.catalog) {
+                    suggestions.push(`Or use the default catalog ("catalog:")`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${BUN_CATALOG_FILENAME}`, suggestions));
+            }
+        }
+        if (!catalogToUse[packageName]) {
+            const catalogName = catalogRef.isDefaultCatalog
+                ? 'default catalog ("catalog")'
+                : `catalog '${catalogRef.catalogName}'`;
+            const availablePackages = Object.keys(catalogToUse);
+            const suggestions = [
+                `Add "${packageName}" to ${catalogName} in ${BUN_CATALOG_FILENAME}`,
+            ];
+            if (availablePackages.length > 0) {
+                suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages
+                    .map((p) => `"${p}"`)
+                    .join(', ')}`);
+            }
+            throw new Error((0, manager_1.formatCatalogError)(`Package "${packageName}" not found in ${catalogName}`, suggestions));
+        }
+    }
+    updateCatalogVersions(treeOrRoot, updates) {
+        (0, bun_manager_utils_1.updateBunCatalogVersionsInFile)(BUN_CATALOG_FILENAME, treeOrRoot, updates);
+    }
+}
+exports.BunCatalogManager = BunCatalogManager;

package/dist/src/utils/catalog/index.d.ts

@@ -4,7 +4,7 @@ import type { CatalogManager } from './manager';
 import { getCatalogManager } from './manager-factory';
 export { type CatalogManager, getCatalogManager };
 /**
- * Dereferences a pnpm/yarn catalog reference to a concrete version spec. Returns
+ * Dereferences a pnpm/yarn/bun catalog reference to a concrete version spec. Returns
  * the input unchanged when it is not a catalog reference (or no catalog manager
  * applies). Throws when the reference cannot be resolved.
  */

package/dist/src/utils/catalog/index.js

@@ -9,7 +9,7 @@ const workspace_root_1 = require("../workspace-root");
 const manager_factory_1 = require("./manager-factory");
 Object.defineProperty(exports, "getCatalogManager", { enumerable: true, get: function () { return manager_factory_1.getCatalogManager; } });
 /**
- * Dereferences a pnpm/yarn catalog reference to a concrete version spec. Returns
+ * Dereferences a pnpm/yarn/bun catalog reference to a concrete version spec. Returns
  * the input unchanged when it is not a catalog reference (or no catalog manager
  * applies). Throws when the reference cannot be resolved.
  */

package/dist/src/utils/catalog/manager-factory.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCatalogManager = getCatalogManager;
 const package_manager_1 = require("../package-manager");
+const bun_manager_1 = require("./bun-manager");
 const pnpm_manager_1 = require("./pnpm-manager");
 const yarn_manager_1 = require("./yarn-manager");
 /**
@@ -14,6 +15,8 @@ function getCatalogManager(workspaceRoot) {
             return new pnpm_manager_1.PnpmCatalogManager();
         case 'yarn':
             return new yarn_manager_1.YarnCatalogManager();
+        case 'bun':
+            return new bun_manager_1.BunCatalogManager();
         default:
             return null;
     }

package/dist/src/utils/catalog/manager-utils.d.ts

@@ -5,4 +5,11 @@ export declare function updateCatalogVersionsInFile(filename: string, treeOrRoot
     packageName: string;
     version: string;
     catalogName?: string;
-}>): void;
+}>, options?: {
+    /**
+     * Treat "default" as an alias for the `catalog` field and route default
+     * updates through a populated `catalogs.default` (pnpm semantics). When
+     * false, "default" is an ordinary named catalog (yarn semantics).
+     */
+    aliasDefaultCatalog?: boolean;
+}): void;

package/dist/src/utils/catalog/manager-utils.js

@@ -136,7 +136,8 @@ function readCatalogDefinitions(filename, treeOrRoot, cache) {
     }
     return readCatalogConfigFromTree(filename, treeOrRoot);
 }
-function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
+function updateCatalogVersionsInFile(filename, treeOrRoot, updates, options) {
+    const aliasDefaultCatalog = options?.aliasDefaultCatalog ?? true;
     let checkExists;
     let readYaml;
     let writeYaml;
@@ -194,13 +195,17 @@ function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
         let hasChanges = false;
         for (const update of updates) {
             const { packageName, version, catalogName } = update;
-            const normalizedCatalogName = catalogName === 'default' ? undefined : catalogName;
+            const normalizedCatalogName = aliasDefaultCatalog && catalogName === 'default'
+                ? undefined
+                : catalogName;
             let targetPath;
             if (!normalizedCatalogName) {
                 // An empty `catalog:` placeholder must not claim the default route
                 // when `catalogs.default` is populated; that would create a
-                // duplicate-default config rejected by pnpm.
-                if (isMapAt(doc, ['catalog'])) {
+                // duplicate-default config rejected by pnpm. Without the alias,
+                // "default" is an ordinary named catalog and the default route is
+                // always the `catalog` field.
+                if (!aliasDefaultCatalog || isMapAt(doc, ['catalog'])) {
                     targetPath = ['catalog', packageName];
                 }
                 else if (existsAt(doc, ['catalogs', 'default'])) {

package/dist/src/utils/catalog/manager.d.ts

@@ -1,6 +1,12 @@
 import type { Tree } from '../../generators/tree';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 export declare function formatCatalogError(error: string, suggestions: string[]): string;
+/**
+ * Shared implementation of getCatalogReferencesForPackage: enumerates the
+ * default and named catalog references and keeps those the manager resolves,
+ * so per-manager default-catalog semantics apply without duplication.
+ */
+export declare function collectCatalogReferencesForPackage(manager: CatalogManager, treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
 /**
  * Interface for catalog managers that handle package manager-specific catalog implementations.
  */
@@ -19,6 +25,12 @@ export interface CatalogManager {
      */
     resolveCatalogReference(workspaceRoot: string, packageName: string, version: string): string | null;
     resolveCatalogReference(tree: Tree, packageName: string, version: string): string | null;
+    /**
+     * Get every catalog reference that resolves to a version for a package,
+     * following the package manager's own default-catalog semantics.
+     */
+    getCatalogReferencesForPackage(workspaceRoot: string, packageName: string): CatalogReferenceMatch[];
+    getCatalogReferencesForPackage(tree: Tree, packageName: string): CatalogReferenceMatch[];
     /**
      * Check that a catalog reference is valid.
      */

package/dist/src/utils/catalog/manager.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCatalogError = formatCatalogError;
+exports.collectCatalogReferencesForPackage = collectCatalogReferencesForPackage;
 function formatCatalogError(error, suggestions) {
     let message = error;
     if (suggestions.length > 0) {
@@ -11,3 +12,32 @@ function formatCatalogError(error, suggestions) {
     }
     return message;
 }
+/**
+ * Shared implementation of getCatalogReferencesForPackage: enumerates the
+ * default and named catalog references and keeps those the manager resolves,
+ * so per-manager default-catalog semantics apply without duplication.
+ */
+function collectCatalogReferencesForPackage(manager, treeOrRoot, packageName) {
+    // The overload pairs don't accept the Tree | string union directly.
+    const source = treeOrRoot;
+    const catalogDefs = manager.getCatalogDefinitions(source);
+    if (!catalogDefs) {
+        return [];
+    }
+    const catalogRefs = ['catalog:'];
+    for (const name of Object.keys(catalogDefs.catalogs ?? {})) {
+        // Skip names the manager treats as the default catalog (e.g. pnpm's
+        // "default") — already covered by the `catalog:` candidate.
+        if (!manager.parseCatalogReference(`catalog:${name}`)?.isDefaultCatalog) {
+            catalogRefs.push(`catalog:${name}`);
+        }
+    }
+    const matches = [];
+    for (const catalogRef of catalogRefs) {
+        const versionSpec = manager.resolveCatalogReference(source, packageName, catalogRef);
+        if (versionSpec) {
+            matches.push({ catalogRef, versionSpec });
+        }
+    }
+    return matches;
+}

package/dist/src/utils/catalog/pnpm-manager.d.ts

@@ -1,6 +1,6 @@
 import type { Tree } from '../../generators/tree';
 import { type CatalogManager } from './manager';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 /**
  * PNPM-specific catalog manager implementation
  */
@@ -13,6 +13,7 @@ export declare class PnpmCatalogManager implements CatalogManager {
     getCatalogDefinitionFilePaths(): string[];
     getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
     resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
     validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
     updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
         packageName: string;

package/dist/src/utils/catalog/pnpm-manager.js

@@ -54,6 +54,9 @@ class PnpmCatalogManager {
         }
         return catalogToUse?.[packageName] || null;
     }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
     validateCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);
         if (!catalogRef) {

package/dist/src/utils/catalog/types.d.ts

@@ -2,6 +2,10 @@ export interface CatalogReference {
     catalogName?: string;
     isDefaultCatalog: boolean;
 }
+export interface CatalogReferenceMatch {
+    catalogRef: string;
+    versionSpec: string;
+}
 export interface CatalogEntry {
     [packageName: string]: string;
 }

package/dist/src/utils/catalog/yarn-manager.d.ts

@@ -1,8 +1,11 @@
 import type { Tree } from '../../generators/tree';
 import { type CatalogManager } from './manager';
-import type { CatalogDefinitions, CatalogReference } from './types';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
 /**
- * Yarn Berry (v4+) catalog manager implementation
+ * Yarn Berry (v4.10+) catalog manager implementation.
+ *
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
  */
 export declare class YarnCatalogManager implements CatalogManager {
     readonly name = "yarn";
@@ -13,6 +16,7 @@ export declare class YarnCatalogManager implements CatalogManager {
     getCatalogDefinitionFilePaths(): string[];
     getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
     resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
     validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
     updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
         packageName: string;

package/dist/src/utils/catalog/yarn-manager.js

@@ -5,7 +5,10 @@ const manager_1 = require("./manager");
 const manager_utils_1 = require("./manager-utils");
 const YARNRC_FILENAME = '.yarnrc.yml';
 /**
- * Yarn Berry (v4+) catalog manager implementation
+ * Yarn Berry (v4.10+) catalog manager implementation.
+ *
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
  */
 class YarnCatalogManager {
     constructor() {
@@ -22,8 +25,9 @@ class YarnCatalogManager {
             return null;
         }
         const catalogName = version.substring(this.catalogProtocol.length);
-        // Normalize both "catalog:" and "catalog:default" to the same representation
-        const isDefault = !catalogName || catalogName === 'default';
+        // Only an empty name selects the default catalog; unlike pnpm, "default"
+        // is a regular named catalog in yarn.
+        const isDefault = !catalogName;
         return {
             catalogName: isDefault ? undefined : catalogName,
             isDefaultCatalog: isDefault,
@@ -46,14 +50,16 @@ class YarnCatalogManager {
         }
         let catalogToUse;
         if (catalogRef.isDefaultCatalog) {
-            // Check both locations for default catalog
-            catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
+            catalogToUse = catalogDefs.catalog;
         }
         else if (catalogRef.catalogName) {
             catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
         }
         return catalogToUse?.[packageName] || null;
     }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
     validateCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);
         if (!catalogRef) {
@@ -65,13 +71,9 @@ class YarnCatalogManager {
         }
         let catalogToUse;
         if (catalogRef.isDefaultCatalog) {
-            const hasCatalog = !!catalogDefs.catalog;
-            const hasCatalogsDefault = !!catalogDefs.catalogs?.default;
-            // Error if both defined
-            if (hasCatalog && hasCatalogsDefault) {
-                throw new Error("The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
-            }
-            catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
+            // Yarn's default catalog is only the `catalog` field; unlike pnpm,
+            // `catalogs.default` does not act as a fallback.
+            catalogToUse = catalogDefs.catalog;
             if (!catalogToUse) {
                 const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
                 const suggestions = [
@@ -88,12 +90,7 @@ class YarnCatalogManager {
         else if (catalogRef.catalogName) {
             catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
             if (!catalogToUse) {
-                const availableCatalogs = Object.keys(catalogDefs.catalogs || {}).filter((c) => c !== 'default');
-                const defaultCatalog = !!catalogDefs.catalog
-                    ? 'catalog'
-                    : !catalogDefs.catalogs?.default
-                        ? 'catalogs.default'
-                        : null;
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
                 const suggestions = [
                     `Define the catalog in ${YARNRC_FILENAME} under the "catalogs" key`,
                 ];
@@ -102,24 +99,16 @@ class YarnCatalogManager {
                         .map((c) => `"catalog:${c}"`)
                         .join(', ')}`);
                 }
-                if (defaultCatalog) {
-                    suggestions.push(`Or use the default catalog ("${defaultCatalog}")`);
+                if (catalogDefs.catalog) {
+                    suggestions.push(`Or use the default catalog ("catalog:")`);
                 }
                 throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${YARNRC_FILENAME}`, suggestions));
             }
         }
         if (!catalogToUse[packageName]) {
-            let catalogName;
-            if (catalogRef.isDefaultCatalog) {
-                // Context-aware messaging based on which location exists
-                const hasCatalog = !!catalogDefs.catalog;
-                catalogName = hasCatalog
-                    ? 'default catalog ("catalog")'
-                    : 'default catalog ("catalogs.default")';
-            }
-            else {
-                catalogName = `catalog '${catalogRef.catalogName}'`;
-            }
+            const catalogName = catalogRef.isDefaultCatalog
+                ? 'default catalog ("catalog")'
+                : `catalog '${catalogRef.catalogName}'`;
             const availablePackages = Object.keys(catalogToUse);
             const suggestions = [
                 `Add "${packageName}" to ${catalogName} in ${YARNRC_FILENAME}`,
@@ -133,7 +122,9 @@ class YarnCatalogManager {
         }
     }
     updateCatalogVersions(treeOrRoot, updates) {
-        (0, manager_utils_1.updateCatalogVersionsInFile)(YARNRC_FILENAME, treeOrRoot, updates);
+        (0, manager_utils_1.updateCatalogVersionsInFile)(YARNRC_FILENAME, treeOrRoot, updates, {
+            aliasDefaultCatalog: false,
+        });
     }
 }
 exports.YarnCatalogManager = YarnCatalogManager;

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

@@ -36,6 +36,21 @@ export interface VcsRemoteInfo {
 }
 export declare function parseVcsRemoteUrl(url: string): VcsRemoteInfo | null;
 export declare function getVcsRemoteInfo(directory?: string): VcsRemoteInfo | null;
+export declare function getGitRootPath(cwd?: string): string;
+/**
+ * Path of `directory` relative to its git root, posix-separated so it is
+ * identical on every OS, and '' when the directory is the git root itself.
+ * Null outside a git repository.
+ */
+export declare function getGitRootRelativePath(directory: string): string | null;
+/** A shallow clone's truncated history has no stable root commit. */
+export declare function isShallowRepository(directory?: string): boolean;
+/**
+ * SHA of the repository's first commit. Merged unrelated histories leave
+ * several root commits — the sorted-first one is picked so every clone
+ * agrees. Null when there are no commits, or outside a git repository.
+ */
+export declare function getFirstCommitSha(directory?: string): string | null;
 export declare function isGitRepository(directory?: string): boolean;
 export declare function getGitCurrentBranch(directory?: string): string | null;
 export declare function hasUncommittedChanges(directory?: string): boolean;

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

@@ -4,6 +4,10 @@ exports.GitRepository = void 0;
 exports.cloneFromUpstream = cloneFromUpstream;
 exports.parseVcsRemoteUrl = parseVcsRemoteUrl;
 exports.getVcsRemoteInfo = getVcsRemoteInfo;
+exports.getGitRootPath = getGitRootPath;
+exports.getGitRootRelativePath = getGitRootRelativePath;
+exports.isShallowRepository = isShallowRepository;
+exports.getFirstCommitSha = getFirstCommitSha;
 exports.isGitRepository = isGitRepository;
 exports.getGitCurrentBranch = getGitCurrentBranch;
 exports.hasUncommittedChanges = hasUncommittedChanges;
@@ -49,12 +53,7 @@ class GitRepository {
         this.root = this.getGitRootPath(this.directory);
     }
     getGitRootPath(cwd) {
-        return (0, child_process_1.execFileSync)('git', ['rev-parse', '--show-toplevel'], {
-            cwd,
-            windowsHide: true,
-        })
-            .toString()
-            .trim();
+        return getGitRootPath(cwd);
     }
     async hasUncommittedChanges() {
         const data = await this.execGit(['status', '--porcelain']);
@@ -297,6 +296,65 @@ function getVcsRemoteInfo(directory) {
         return null;
     }
 }
+function getGitRootPath(cwd) {
+    return (0, child_process_1.execFileSync)('git', ['rev-parse', '--show-toplevel'], {
+        cwd,
+        windowsHide: true,
+    })
+        .toString()
+        .trim();
+}
+/**
+ * Path of `directory` relative to its git root, posix-separated so it is
+ * identical on every OS, and '' when the directory is the git root itself.
+ * Null outside a git repository.
+ */
+function getGitRootRelativePath(directory) {
+    try {
+        return (0, path_1.relative)(getGitRootPath(directory), directory)
+            .split(path_1.sep)
+            .join(path_1.posix.sep);
+    }
+    catch {
+        return null;
+    }
+}
+/** A shallow clone's truncated history has no stable root commit. */
+function isShallowRepository(directory) {
+    try {
+        return ((0, child_process_1.execFileSync)('git', ['rev-parse', '--is-shallow-repository'], {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            cwd: directory,
+            windowsHide: true,
+        }).trim() === 'true');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * SHA of the repository's first commit. Merged unrelated histories leave
+ * several root commits — the sorted-first one is picked so every clone
+ * agrees. Null when there are no commits, or outside a git repository.
+ */
+function getFirstCommitSha(directory) {
+    try {
+        const roots = (0, child_process_1.execFileSync)('git', ['rev-list', '--max-parents=0', 'HEAD'], {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            cwd: directory,
+            windowsHide: true,
+        })
+            .trim()
+            .split(/\r?\n/)
+            .filter(Boolean);
+        return roots.sort()[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 function isGitRepository(directory) {
     try {
         (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', {

package/dist/src/utils/package-manager.d.ts

@@ -121,7 +121,9 @@ export declare function resolvePackageVersionUsingInstallation(packageName: stri
 export declare function packageRegistryView(pkg: string, version: string, args: string, options?: {
     forceNpm?: boolean;
 }): Promise<string>;
-export declare function packageRegistryPack(cwd: string, pkg: string, version: string): Promise<{
+export declare function packageRegistryPack(cwd: string, pkg: string, version: string, options?: {
+    bypassMinReleaseAge?: boolean;
+}): Promise<{
     tarballPath: string;
 }>;
 /**

package/dist/src/utils/package-manager.js

@@ -349,6 +349,20 @@ function modifyPnpmWorkspaceYamlToFitNewDirectory(contents) {
     doc.set('packages', ['.']);
     // Relative patch paths don't resolve in the temp dir.
     doc.delete('patchedDependencies');
+    // link:/file: overrides (e.g. written by `pnpm link`) point at paths that
+    // don't exist in the temp dir, and an override would hijack an exact-version
+    // add (`pnpm add pkg@x.y.z` would install the linked dir instead).
+    const overrides = doc.toJS()?.overrides;
+    if (overrides && typeof overrides === 'object') {
+        for (const [name, spec] of Object.entries(overrides)) {
+            if (typeof spec === 'string' && /^(link|file):/.test(spec)) {
+                doc.deleteIn(['overrides', name]);
+            }
+        }
+        if (Object.keys(doc.toJS()?.overrides ?? {}).length === 0) {
+            doc.delete('overrides');
+        }
+    }
     return doc.toString();
 }
 function copyPackageManagerConfigurationFiles(root, destination) {
@@ -519,7 +533,7 @@ options) {
     });
     return stdout.toString().trim();
 }
-async function packageRegistryPack(cwd, pkg, version) {
+async function packageRegistryPack(cwd, pkg, version, options) {
     /**
      * Only `npm pack` supports downloading a tarball of a specified remote
      * package. `yarn` packs the active workspace, `pnpm pack` only packs
@@ -533,7 +547,13 @@ async function packageRegistryPack(cwd, pkg, version) {
         windowsHide: true,
         // npm enforces `devEngines.packageManager` even on `pack`; force keeps the
         // download working in workspaces that pin a non-npm manager (onFail: error).
-        env: { ...process.env, npm_config_force: 'true' },
+        env: {
+            ...process.env,
+            npm_config_force: 'true',
+            ...(options?.bypassMinReleaseAge
+                ? { npm_config_min_release_age: '0' }
+                : {}),
+        },
     });
     const tarballPath = stdout.trim();
     return { tarballPath };

package/dist/src/utils/workspace-id.d.ts

@@ -0,0 +1,20 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+/**
+ * The workspace's analytics identity: the Nx Cloud id when the workspace has
+ * one (most stable — it survives repo moves and renames), else the repo key.
+ * Null when neither is available, in which case nothing is reported.
+ */
+export declare function generateWorkspaceId(root: string, nxJson: NxJsonConfiguration | null): string | null;
+/**
+ * Derive the stable, unsalted key identifying this workspace in the
+ * repoTelemetry registry: `sha256(<repo identity> + '#' + <workspace path
+ * relative to the git root>)`.
+ *
+ * The repo identity is the normalized `domain/slug` from the git remote
+ * (protocol-independent: ssh, https, and token-authenticated URLs of the
+ * same repo produce the same key), falling back to the first-commit SHA
+ * when no remote exists. Returns null when no identity is derivable — not
+ * a git repository, or a shallow clone without a remote.
+ */
+export declare function deriveRepoKey(directory: string): string | null;
+export declare function computeRepoKey(identity: string, relativePath: string): string;