nx 22.2.0-canary.20251203-2e442d5 → 22.2.0-canary.20251204-0f24bf5

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

@@ -22,6 +22,7 @@ exports.BUN_LOCK_FILE = 'bun.lockb';
 exports.BUN_TEXT_LOCK_FILE = 'bun.lock';
 let currentLockFileHash;
 let cachedParsedLockFile;
+let cachedPackageIndex;
 const keyMap = new Map();
 const packageVersions = new Map();
 const specParseCache = new Map();
@@ -46,16 +47,13 @@ function readBunLockFile(lockFilePath) {
 }
 function getBunTextLockfileDependencies(lockFileContent, lockFileHash, ctx) {
     try {
-        const lockFile = parseLockFile(lockFileContent, lockFileHash);
+        const { lockFile, index } = parseLockFile(lockFileContent, lockFileHash);
         const dependencies = [];
         const workspacePackages = new Set(Object.keys(ctx.projects));
         if (!lockFile.workspaces || Object.keys(lockFile.workspaces).length === 0) {
             return dependencies;
         }
-        // Pre-compute workspace collections for performance
-        const workspacePackageNames = getWorkspacePackageNames(lockFile);
-        const workspacePaths = getWorkspacePaths(lockFile);
-        const packageDeps = processPackageToPackageDependencies(lockFile, ctx, workspacePackages, workspacePackageNames, workspacePaths);
+        const packageDeps = processPackageToPackageDependencies(lockFile, index, ctx, workspacePackages);
         dependencies.push(...packageDeps);
         return dependencies;
     }
@@ -70,18 +68,21 @@ function getBunTextLockfileDependencies(lockFileContent, lockFileHash, ctx) {
 function clearCache() {
     currentLockFileHash = undefined;
     cachedParsedLockFile = undefined;
+    cachedPackageIndex = undefined;
     keyMap.clear();
     packageVersions.clear();
     specParseCache.clear();
 }
 // ===== UTILITY FUNCTIONS =====
 function getCachedSpecInfo(resolvedSpec) {
-    if (!specParseCache.has(resolvedSpec)) {
+    let cached = specParseCache.get(resolvedSpec);
+    if (!cached) {
         const { name, version } = parseResolvedSpec(resolvedSpec);
         const protocol = getProtocolFromResolvedSpec(resolvedSpec);
-        specParseCache.set(resolvedSpec, { name, version, protocol });
+        cached = { name, version, protocol };
+        specParseCache.set(resolvedSpec, cached);
     }
-    return specParseCache.get(resolvedSpec);
+    return cached;
 }
 function getProtocolFromResolvedSpec(resolvedSpec) {
     // Handle scoped packages properly
@@ -228,9 +229,112 @@ function calculatePackageHash(packageData, lockFile, name, version) {
 function isAliasPackage(packageKey, resolvedPackageName) {
     return packageKey !== resolvedPackageName;
 }
+/**
+ * Build a pre-computed index for O(1) lookups
+ * This is the key optimization - we do one pass through all packages
+ * and build indexes that can be queried in O(1) time later
+ */
+function buildPackageIndex(lockFile) {
+    const byName = new Map();
+    const workspaceNames = new Set();
+    const workspacePaths = new Set();
+    const packagesWithWorkspaceVariants = new Set();
+    const patchedPackages = new Set();
+    // Collect workspace paths
+    if (lockFile.workspaces) {
+        for (const workspacePath of Object.keys(lockFile.workspaces)) {
+            if (workspacePath !== '') {
+                workspacePaths.add(workspacePath);
+            }
+        }
+    }
+    // Collect workspace package names from workspacePackages field
+    if (lockFile.workspacePackages) {
+        for (const packageInfo of Object.values(lockFile.workspacePackages)) {
+            workspaceNames.add(packageInfo.name);
+        }
+    }
+    // Collect patched package names
+    if (lockFile.patches) {
+        for (const packageName of Object.keys(lockFile.patches)) {
+            patchedPackages.add(packageName);
+        }
+    }
+    // Collect workspace package names from workspace dependencies
+    if (lockFile.workspaces) {
+        for (const workspace of Object.values(lockFile.workspaces)) {
+            const allDeps = {
+                ...workspace.dependencies,
+                ...workspace.devDependencies,
+                ...workspace.optionalDependencies,
+                ...workspace.peerDependencies,
+            };
+            for (const [depName, depVersion] of Object.entries(allDeps)) {
+                if (depVersion.startsWith('workspace:') ||
+                    depVersion.startsWith('file:')) {
+                    workspaceNames.add(depName);
+                }
+            }
+        }
+    }
+    // Single pass through all packages to build indexes
+    if (lockFile.packages) {
+        for (const [packageKey, packageData] of Object.entries(lockFile.packages)) {
+            if (!Array.isArray(packageData) || packageData.length < 1) {
+                continue;
+            }
+            const resolvedSpec = packageData[0];
+            if (typeof resolvedSpec !== 'string') {
+                continue;
+            }
+            const { name, version, protocol } = getCachedSpecInfo(resolvedSpec);
+            if (!name || !version) {
+                continue;
+            }
+            // Track workspace packages from packages section
+            if (protocol === 'workspace' || protocol === 'file') {
+                workspaceNames.add(name);
+            }
+            // Check if this is a workspace-specific variant (e.g., "@quz/pkg1/lodash")
+            if (packageKey.includes('/') && packageKey !== name) {
+                // Check if it ends with a package name pattern
+                const lastSlash = packageKey.lastIndexOf('/');
+                if (lastSlash > 0) {
+                    const possiblePackageName = packageKey.substring(lastSlash + 1);
+                    const prefix = packageKey.substring(0, lastSlash);
+                    // If the prefix is a workspace path or scoped package pattern
+                    // For scoped packages, require prefix to contain '/' (e.g., "@scope/pkg")
+                    // to avoid incorrectly matching just "@scope"
+                    if (workspacePaths.has(prefix) ||
+                        (prefix.startsWith('@') && prefix.includes('/'))) {
+                        packagesWithWorkspaceVariants.add(possiblePackageName);
+                    }
+                }
+            }
+            // Build the byName index
+            let entries = byName.get(name);
+            if (!entries) {
+                entries = [];
+                byName.set(name, entries);
+            }
+            // Calculate hash once
+            const hash = calculatePackageHash(packageData, lockFile, name, version);
+            entries.push({ version, packageKey, hash });
+        }
+    }
+    return {
+        byName,
+        workspaceNames,
+        workspacePaths,
+        packagesWithWorkspaceVariants,
+        patchedPackages,
+    };
+}
 function parseLockFile(lockFileContent, lockFileHash) {
-    if (currentLockFileHash === lockFileHash) {
-        return cachedParsedLockFile;
+    if (currentLockFileHash === lockFileHash &&
+        cachedParsedLockFile &&
+        cachedPackageIndex) {
+        return { lockFile: cachedParsedLockFile, index: cachedPackageIndex };
     }
     clearCache();
     try {
@@ -296,7 +400,9 @@ function parseLockFile(lockFileContent, lockFileHash) {
         }
         cachedParsedLockFile = result;
         currentLockFileHash = lockFileHash;
-        return result;
+        // Build the optimized index
+        cachedPackageIndex = buildPackageIndex(result);
+        return { lockFile: result, index: cachedPackageIndex };
     }
     catch (error) {
         // Handle JSON parsing errors
@@ -315,23 +421,20 @@ function parseLockFile(lockFileContent, lockFileHash) {
 // ===== MAIN EXPORT FUNCTIONS =====
 function getBunTextLockfileNodes(lockFileContent, lockFileHash) {
     try {
-        const lockFile = parseLockFile(lockFileContent, lockFileHash);
+        const { lockFile, index } = parseLockFile(lockFileContent, lockFileHash);
         const nodes = {};
-        const packageVersions = new Map();
+        const localPackageVersions = new Map();
         if (!lockFile.packages || Object.keys(lockFile.packages).length === 0) {
             return nodes;
         }
-        // Pre-compute workspace collections for performance
-        const workspacePaths = getWorkspacePaths(lockFile);
-        const workspacePackageNames = getWorkspacePackageNames(lockFile);
         const packageEntries = Object.entries(lockFile.packages);
         for (const [packageKey, packageData] of packageEntries) {
-            const result = processPackageEntry(packageKey, packageData, lockFile, keyMap, nodes, packageVersions);
+            const result = processPackageEntry(packageKey, packageData, lockFile, index, keyMap, nodes, localPackageVersions);
             if (result.shouldContinue) {
                 continue;
             }
         }
-        createHoistedNodes(packageVersions, lockFile, keyMap, nodes, workspacePaths, workspacePackageNames);
+        createHoistedNodes(localPackageVersions, lockFile, index, keyMap, nodes);
         return nodes;
     }
     catch (error) {
@@ -341,7 +444,7 @@ function getBunTextLockfileNodes(lockFileContent, lockFileHash) {
         throw new Error(`Failed to get Bun lockfile nodes: ${error.message}`);
     }
 }
-function processPackageEntry(packageKey, packageData, lockFile, keyMap, nodes, packageVersions) {
+function processPackageEntry(packageKey, packageData, lockFile, index, keyMap, nodes, packageVersions) {
     try {
         if (!Array.isArray(packageData) ||
             packageData.length < 1 ||
@@ -359,16 +462,17 @@ function processPackageEntry(packageKey, packageData, lockFile, keyMap, nodes, p
             console.warn(`Lockfile contains unrecognized package format. Try regenerating the lockfile with 'bun install --force'.\nDebug: could not parse resolved spec '${resolvedSpec}'`);
             return { shouldContinue: true };
         }
-        if (isWorkspacePackage(name, lockFile)) {
+        // O(1) lookups using index
+        if (index.workspaceNames.has(name)) {
             return { shouldContinue: true };
         }
-        if (lockFile.patches && lockFile.patches[name]) {
+        if (index.patchedPackages.has(name)) {
             return { shouldContinue: true };
         }
         if (protocol === 'workspace') {
             return { shouldContinue: true };
         }
-        const isWorkspaceSpecific = isNestedPackageKey(packageKey, lockFile);
+        const isWorkspaceSpecific = isNestedPackageKey(packageKey, index);
         if (!isWorkspaceSpecific && isAliasPackage(packageKey, name)) {
             const aliasName = packageKey;
             const actualPackageName = name;
@@ -442,11 +546,10 @@ function processPackageEntry(packageKey, packageData, lockFile, keyMap, nodes, p
         return { shouldContinue: true };
     }
 }
-function isWorkspaceOrPatchedPackage(packageName, lockFile, workspacePackages, workspacePackageNames) {
+function isWorkspaceOrPatchedPackage(packageName, index, workspacePackages) {
     return (workspacePackages.has(packageName) ||
-        workspacePackageNames.has(packageName) ||
-        isWorkspacePackage(packageName, lockFile) ||
-        (lockFile.patches && !!lockFile.patches[packageName]));
+        index.workspaceNames.has(packageName) ||
+        index.patchedPackages.has(packageName));
 }
 function resolveAliasTarget(versionSpec) {
     if (!versionSpec.startsWith('npm:'))
@@ -458,15 +561,7 @@ function resolveAliasTarget(versionSpec) {
         version: actualSpec.substring(actualAtIndex + 1),
     };
 }
-function getAllWorkspaceDependencies(workspace) {
-    return {
-        ...workspace.dependencies,
-        ...workspace.devDependencies,
-        ...workspace.optionalDependencies,
-        ...workspace.peerDependencies,
-    };
-}
-function processPackageToPackageDependencies(lockFile, ctx, workspacePackages, workspacePackageNames, workspacePaths) {
+function processPackageToPackageDependencies(lockFile, index, ctx, workspacePackages) {
     const dependencies = [];
     if (!lockFile.packages || Object.keys(lockFile.packages).length === 0) {
         return dependencies;
@@ -474,7 +569,7 @@ function processPackageToPackageDependencies(lockFile, ctx, workspacePackages, w
     const packageEntries = Object.entries(lockFile.packages);
     for (const [packageKey, packageData] of packageEntries) {
         try {
-            const packageDeps = processPackageForDependencies(packageKey, packageData, lockFile, ctx, workspacePackages, workspacePackageNames, workspacePaths);
+            const packageDeps = processPackageForDependencies(packageKey, packageData, lockFile, index, ctx, workspacePackages);
             dependencies.push(...packageDeps);
         }
         catch (error) {
@@ -483,9 +578,10 @@ function processPackageToPackageDependencies(lockFile, ctx, workspacePackages, w
     }
     return dependencies;
 }
-function processPackageForDependencies(packageKey, packageData, lockFile, ctx, workspacePackages, workspacePackageNames, workspacePaths) {
-    if (isWorkspacePackage(packageKey, lockFile) ||
-        isNestedPackageKey(packageKey, lockFile, workspacePaths, workspacePackageNames)) {
+function processPackageForDependencies(packageKey, packageData, lockFile, index, ctx, workspacePackages) {
+    // O(1) checks using index
+    if (index.workspaceNames.has(packageKey) ||
+        isNestedPackageKey(packageKey, index)) {
         return [];
     }
     if (!Array.isArray(packageData) || packageData.length < 1) {
@@ -499,7 +595,7 @@ function processPackageForDependencies(packageKey, packageData, lockFile, ctx, w
     if (!sourcePackageName || !sourceVersion) {
         return [];
     }
-    if (lockFile.patches && lockFile.patches[sourcePackageName]) {
+    if (index.patchedPackages.has(sourcePackageName)) {
         return [];
     }
     const sourceNodeName = `npm:${sourcePackageName}@${sourceVersion}`;
@@ -515,7 +611,7 @@ function processPackageForDependencies(packageKey, packageData, lockFile, ctx, w
         const deps = packageDependencies[depType];
         if (!deps || typeof deps !== 'object')
             continue;
-        const depDependencies = processDependencyEntries(deps, sourceNodeName, lockFile, ctx, workspacePackages, workspacePackageNames);
+        const depDependencies = processDependencyEntries(deps, sourceNodeName, index, ctx, workspacePackages, lockFile.manifests);
         dependencies.push(...depDependencies);
     }
     return dependencies;
@@ -533,12 +629,12 @@ function extractPackageDependencies(packageData) {
     }
     return undefined;
 }
-function processDependencyEntries(deps, sourceNodeName, lockFile, ctx, workspacePackages, workspacePackageNames) {
+function processDependencyEntries(deps, sourceNodeName, index, ctx, workspacePackages, manifests) {
     const dependencies = [];
     const depsEntries = Object.entries(deps);
     for (const [packageName, versionSpec] of depsEntries) {
         try {
-            const dependency = processSingleDependency(packageName, versionSpec, sourceNodeName, lockFile, ctx, workspacePackages, workspacePackageNames);
+            const dependency = processSingleDependency(packageName, versionSpec, sourceNodeName, index, ctx, workspacePackages, manifests);
             if (dependency) {
                 dependencies.push(dependency);
             }
@@ -549,11 +645,12 @@ function processDependencyEntries(deps, sourceNodeName, lockFile, ctx, workspace
     }
     return dependencies;
 }
-function processSingleDependency(packageName, versionSpec, sourceNodeName, lockFile, ctx, workspacePackages, workspacePackageNames) {
+function processSingleDependency(packageName, versionSpec, sourceNodeName, index, ctx, workspacePackages, manifests) {
     if (typeof packageName !== 'string' || typeof versionSpec !== 'string') {
         return null;
     }
-    if (isWorkspaceOrPatchedPackage(packageName, lockFile, workspacePackages, workspacePackageNames)) {
+    // O(1) check using index
+    if (isWorkspaceOrPatchedPackage(packageName, index, workspacePackages)) {
         return null;
     }
     if (versionSpec.startsWith('workspace:')) {
@@ -567,7 +664,8 @@ function processSingleDependency(packageName, versionSpec, sourceNodeName, lockF
         targetVersion = aliasTarget.version;
     }
     else {
-        const resolvedVersion = findResolvedVersion(packageName, versionSpec, lockFile.packages, lockFile.manifests);
+        // O(1) lookup using index instead of O(n) scan
+        const resolvedVersion = findResolvedVersion(packageName, versionSpec, index, manifests);
         if (!resolvedVersion) {
             return null;
         }
@@ -601,70 +699,12 @@ function resolveTargetNodeName(targetPackageName, targetVersion, ctx) {
     }
     return null;
 }
-// ===== WORKSPACE-RELATED FUNCTIONS =====
-function getWorkspacePackageNames(lockFile) {
-    const workspacePackageNames = new Set();
-    if (lockFile.workspacePackages) {
-        for (const packageInfo of Object.values(lockFile.workspacePackages)) {
-            workspacePackageNames.add(packageInfo.name);
-        }
-    }
-    return workspacePackageNames;
-}
-function getWorkspacePaths(lockFile) {
-    const workspacePaths = new Set();
-    if (lockFile.workspaces) {
-        for (const workspacePath of Object.keys(lockFile.workspaces)) {
-            if (workspacePath !== '') {
-                workspacePaths.add(workspacePath);
-            }
-        }
-    }
-    return workspacePaths;
-}
-function isWorkspacePackage(packageName, lockFile) {
-    // Check if package is in workspacePackages field
-    if (lockFile.workspacePackages && lockFile.workspacePackages[packageName]) {
-        return true;
-    }
-    // Check if package is defined in any workspace dependencies with workspace: prefix
-    // or if it's a file dependency in workspace dependencies
-    if (lockFile.workspaces) {
-        for (const workspace of Object.values(lockFile.workspaces)) {
-            const allDeps = getAllWorkspaceDependencies(workspace);
-            if (allDeps[packageName]?.startsWith('workspace:')) {
-                return true;
-            }
-            // Check if this is a file dependency defined in workspace dependencies
-            // Always filter out file dependencies as they represent workspace packages
-            if (allDeps[packageName]?.startsWith('file:')) {
-                return true;
-            }
-        }
-    }
-    // Check if package appears in packages section with workspace: or file: protocol
-    if (lockFile.packages) {
-        for (const packageData of Object.values(lockFile.packages)) {
-            if (Array.isArray(packageData) && packageData.length > 0) {
-                const resolvedSpec = packageData[0];
-                if (typeof resolvedSpec === 'string') {
-                    const { name, protocol } = getCachedSpecInfo(resolvedSpec);
-                    if (name === packageName &&
-                        (protocol === 'workspace' || protocol === 'file')) {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-    return false;
-}
 // ===== HOISTING-RELATED FUNCTIONS =====
-function createHoistedNodes(packageVersions, lockFile, keyMap, nodes, workspacePaths, workspacePackageNames) {
+function createHoistedNodes(packageVersions, lockFile, index, keyMap, nodes) {
     for (const [packageName, versions] of packageVersions.entries()) {
         const hoistedNodeKey = `npm:${packageName}`;
-        if (shouldCreateHoistedNode(packageName, lockFile, workspacePaths, workspacePackageNames)) {
-            const hoistedVersion = getHoistedVersion(packageName, versions, lockFile);
+        if (shouldCreateHoistedNode(packageName, lockFile, index)) {
+            const hoistedVersion = getHoistedVersion(packageName, versions, index);
             if (hoistedVersion) {
                 const versionedNodeKey = `npm:${packageName}@${hoistedVersion}`;
                 const versionedNode = keyMap.get(versionedNodeKey);
@@ -689,86 +729,49 @@ function createHoistedNodes(packageVersions, lockFile, keyMap, nodes, workspaceP
  * Checks if a package key represents a workspace-specific or nested dependency entry
  * These entries should not become external nodes, they are used only for resolution
  *
- * Examples of workspace-specific/nested entries:
- * - "@quz/pkg1/lodash" (workspace-specific)
- * - "is-even/is-odd" (dependency nesting)
- * - "@quz/pkg2/is-even/is-odd" (workspace-specific nested)
+ * O(1) lookup using pre-computed index
  */
-function isNestedPackageKey(packageKey, lockFile, workspacePaths, workspacePackageNames) {
+function isNestedPackageKey(packageKey, index) {
     // If the key doesn't contain '/', it's a direct package entry
     if (!packageKey.includes('/')) {
         return false;
     }
-    // Get workspace paths and package names for comparison
-    const computedWorkspacePaths = workspacePaths || getWorkspacePaths(lockFile);
-    const computedWorkspacePackageNames = workspacePackageNames || getWorkspacePackageNames(lockFile);
     // Check if this looks like a workspace-specific or nested entry
     const parts = packageKey.split('/');
     // For multi-part keys, check if the prefix is a workspace path or package name
     if (parts.length >= 2) {
         const prefix = parts.slice(0, -1).join('/');
-        // Check against known workspace paths
-        if (computedWorkspacePaths.has(prefix)) {
+        // O(1) check against known workspace paths
+        if (index.workspacePaths.has(prefix)) {
             return true;
         }
-        // Check against workspace package names (scoped packages)
-        if (computedWorkspacePackageNames.has(prefix)) {
+        // O(1) check against workspace package names (scoped packages)
+        if (index.workspaceNames.has(prefix)) {
             return true;
         }
-        // Check for scoped workspace packages (e.g., "@quz/pkg1")
+        // Check for scoped workspace packages (e.g., "@quz/pkg1/lodash")
+        // The prefix must contain '/' to be a scoped package (e.g., "@scope/pkg")
+        // A prefix like just "@scope" without '/' is not a scoped package
         if (prefix.startsWith('@') && prefix.includes('/')) {
             return true;
         }
+        // If the key looks like a simple scoped package (e.g., "@custom/lodash")
+        // where parts.length === 2 and first part starts with '@', it's likely
+        // a scoped package alias, not a nested dependency
+        if (parts.length === 2 && parts[0].startsWith('@')) {
+            return false;
+        }
         // This could be dependency nesting (e.g., "is-even/is-odd")
-        // These should also be filtered out as they're not direct packages
+        // These should be filtered out as they're not direct packages
         return true;
     }
     return false;
 }
-/**
- * Checks if a package has workspace-specific variants in the lockfile
- * Workspace-specific variants indicate the package should NOT be hoisted
- * Example: "@quz/pkg1/lodash" indicates lodash should not be hoisted for the @quz/pkg1 workspace
- *
- * This should NOT match dependency nesting like "is-even/is-odd" which represents
- * is-odd as a dependency of is-even, not a workspace-specific variant.
- */
-function hasWorkspaceSpecificVariant(packageName, lockFile, workspacePaths, workspacePackageNames) {
-    if (!lockFile.packages)
-        return false;
-    // Get list of known workspace paths to distinguish workspace-specific variants
-    // from dependency nesting
-    const computedWorkspacePaths = workspacePaths || getWorkspacePaths(lockFile);
-    const computedWorkspacePackageNames = workspacePackageNames || getWorkspacePackageNames(lockFile);
-    // Check if any package key follows pattern: "workspace/packageName"
-    for (const packageKey of Object.keys(lockFile.packages)) {
-        if (packageKey.includes('/') && packageKey.endsWith(`/${packageName}`)) {
-            const prefix = packageKey.substring(0, packageKey.lastIndexOf(`/${packageName}`));
-            // Check if prefix is a known workspace path or workspace package name
-            if (computedWorkspacePaths.has(prefix) ||
-                computedWorkspacePackageNames.has(prefix)) {
-                return true;
-            }
-            // Also check for scoped workspace packages (e.g., "@quz/pkg1/lodash")
-            if (prefix.startsWith('@') && prefix.includes('/')) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
 /**
  * Determines if a package should have a hoisted node created
- * A package should be hoisted if:
- * 1. It has a direct entry in the packages section (key matches package name exactly), OR
- * 2. It appears as a direct dependency in any workspace AND no workspace-specific variants exist
- *
- * This handles both cases:
- * - Packages with direct entries (like transitive deps) should be hoisted
- * - Packages in workspace deps without conflicts should be hoisted
- * - Packages with both direct entries and workspace-specific variants get both
+ * O(1) lookup using pre-computed index
  */
-function shouldCreateHoistedNode(packageName, lockFile, workspacePaths, workspacePackageNames) {
+function shouldCreateHoistedNode(packageName, lockFile, index) {
     if (!lockFile.workspaces || !lockFile.packages)
         return false;
     // First check if the package has a direct entry in the packages section
@@ -780,154 +783,126 @@ function shouldCreateHoistedNode(packageName, lockFile, workspacePaths, workspac
     // and don't have workspace-specific variants (which would cause conflicts)
     let appearsInWorkspace = false;
     for (const workspace of Object.values(lockFile.workspaces)) {
-        const allDeps = getAllWorkspaceDependencies(workspace);
+        const allDeps = {
+            ...workspace.dependencies,
+            ...workspace.devDependencies,
+            ...workspace.optionalDependencies,
+            ...workspace.peerDependencies,
+        };
         if (allDeps[packageName]) {
             appearsInWorkspace = true;
             break;
         }
     }
+    // O(1) check using pre-computed index
     if (appearsInWorkspace &&
-        !hasWorkspaceSpecificVariant(packageName, lockFile, workspacePaths, workspacePackageNames)) {
-        return true; // Found in workspace deps and no conflicts
+        !index.packagesWithWorkspaceVariants.has(packageName)) {
+        return true;
     }
     return false;
 }
 /**
  * Gets the version that should be used for a hoisted package
- * For truly hoisted packages, we look up the version from the main package entry
+ * O(1) lookup using pre-computed index
  */
-function getHoistedVersion(packageName, availableVersions, lockFile) {
-    if (!lockFile.packages)
-        return null;
-    // Look for the main package entry (not workspace-specific)
-    const mainPackageData = lockFile.packages[packageName];
-    if (mainPackageData &&
-        Array.isArray(mainPackageData) &&
-        mainPackageData.length > 0) {
-        const resolvedSpec = mainPackageData[0];
-        if (typeof resolvedSpec === 'string') {
-            const { version } = getCachedSpecInfo(resolvedSpec);
-            if (version && availableVersions.has(version)) {
-                return version;
-            }
-        }
+function getHoistedVersion(packageName, availableVersions, index) {
+    // Use the index to find the main package version
+    const candidates = index.byName.get(packageName);
+    if (!candidates || candidates.length === 0) {
+        return availableVersions.size > 0
+            ? availableVersions.values().next().value
+            : null;
+    }
+    // Look for the main package entry (the one where packageKey === packageName)
+    const mainEntry = candidates.find((c) => c.packageKey === packageName);
+    if (mainEntry && availableVersions.has(mainEntry.version)) {
+        return mainEntry.version;
     }
     // Fallback: return the first available version
-    return availableVersions.size > 0 ? Array.from(availableVersions)[0] : null;
+    return availableVersions.size > 0
+        ? availableVersions.values().next().value
+        : null;
 }
 /**
  * Finds the resolved version for a package given its version specification
  *
- * 1. Fast path: Check manifests for exact version match
- * 2. Scan all packages to find candidates with matching names
- * 3. Include alias packages where the target matches our package name
- * 4. Fallback: Search manifests for any matching package entries
- * 5. Use findBestVersionMatch to select the optimal version from candidates
+ * O(1) lookup using pre-computed index instead of O(n) scan through all packages
  */
-function findResolvedVersion(packageName, versionSpec, packages, manifests) {
-    // Look for matching packages and collect all versions
-    const candidateVersions = [];
-    const packageEntries = Object.entries(packages);
-    // Early manifest lookup for exact matches
-    // Avoids expensive package scanning when exact version is available
-    if (manifests) {
-        const exactManifestKey = `${packageName}@${versionSpec}`;
-        if (manifests[exactManifestKey]) {
-            return versionSpec;
-        }
-    }
-    for (const [packageKey, packageData] of packageEntries) {
-        const [resolvedSpec] = packageData;
-        // Skip non-string specs early
-        if (typeof resolvedSpec !== 'string') {
-            continue;
-        }
-        // Use cached spec parsing to avoid repeated string operations
-        const { name, version } = getCachedSpecInfo(resolvedSpec);
-        if (name === packageName) {
-            // Include manifest information if available
-            const manifest = manifests?.[`${name}@${version}`];
-            candidateVersions.push({ version, packageKey, manifest });
-            // Early termination if we find an exact version match
-            if (version === versionSpec) {
-                return version;
-            }
-        }
-        // Check for alias packages where this package might be the target
-        if (isAliasPackage(packageKey, name) && name === packageName) {
-            // This alias points to the package we're looking for
-            const manifest = manifests?.[`${name}@${version}`];
-            candidateVersions.push({ version, packageKey, manifest });
-            // Early termination if we find an exact version match
-            if (version === versionSpec) {
-                return version;
-            }
-        }
-    }
-    if (candidateVersions.length === 0) {
+function findResolvedVersion(packageName, versionSpec, index, manifests) {
+    // O(1) lookup
+    const candidates = index.byName.get(packageName);
+    if (!candidates || candidates.length === 0) {
         // Try to find in manifests as fallback
         if (manifests) {
+            const exactManifestKey = `${packageName}@${versionSpec}`;
+            if (manifests[exactManifestKey]) {
+                return versionSpec;
+            }
             const manifestKey = Object.keys(manifests).find((key) => key.startsWith(`${packageName}@`));
             if (manifestKey) {
                 const manifest = manifests[manifestKey];
-                const version = manifest.version;
-                if (version) {
-                    candidateVersions.push({
-                        version,
-                        packageKey: manifestKey,
-                        manifest,
-                    });
+                if (manifest.version) {
+                    return manifest.version;
                 }
             }
         }
-        if (candidateVersions.length === 0) {
-            return null;
-        }
+        return null;
+    }
+    // Check for exact version match first (most common case)
+    const exactMatch = candidates.find((c) => c.version === versionSpec);
+    if (exactMatch) {
+        return exactMatch.version;
     }
-    // Handle different version specification patterns with enhanced logic
-    const bestMatch = findBestVersionMatch(packageName, versionSpec, candidateVersions);
-    return bestMatch ? bestMatch.version : null;
+    // Handle different version specification patterns
+    return findBestVersionMatch(versionSpec, candidates);
 }
 /**
  * Find the best version match for a given version specification
- *
- * 1. Check for exact version matches first (highest priority)
- * 2. Handle union ranges (||) by recursively checking each range
- * 3. For non-semver versions (git, file, etc.), prefer exact matches or return first candidate
- * 4. For semver versions, use semver.satisfies() to find compatible versions
+ * Only operates on the pre-filtered candidates array (usually 1-3 items)
  */
-function findBestVersionMatch(packageName, versionSpec, candidates) {
-    // For exact matches, return immediately
+function findBestVersionMatch(versionSpec, candidates) {
+    if (candidates.length === 0) {
+        return null;
+    }
+    // For exact matches, return immediately (already checked above but defensive)
     const exactMatch = candidates.find((c) => c.version === versionSpec);
     if (exactMatch) {
-        return exactMatch;
+        return exactMatch.version;
     }
     // Handle union ranges (||)
     if (versionSpec.includes('||')) {
         const ranges = versionSpec.split('||').map((r) => r.trim());
         for (const range of ranges) {
-            const match = findBestVersionMatch(packageName, range, candidates);
+            const match = findBestVersionMatch(range, candidates);
             if (match) {
                 return match;
             }
         }
         return null;
     }
+    // Separate semver and non-semver versions
+    const semverVersions = [];
+    const nonSemverVersions = [];
+    for (const c of candidates) {
+        if (/^\d+\.\d+\.\d+/.test(c.version)) {
+            semverVersions.push(c);
+        }
+        else {
+            nonSemverVersions.push(c);
+        }
+    }
     // Handle non-semver versions (git, file, etc.)
-    const nonSemverVersions = candidates.filter((c) => !c.version.match(/^\d+\.\d+\.\d+/));
     if (nonSemverVersions.length > 0) {
-        // For non-semver versions, use the first match or exact match
         const nonSemverMatch = nonSemverVersions.find((c) => c.version === versionSpec);
         if (nonSemverMatch) {
-            return nonSemverMatch;
+            return nonSemverMatch.version;
         }
-        // If no exact match, return the first non-semver candidate
-        return nonSemverVersions[0];
+        // If no exact match for non-semver, continue to semver matching
     }
     // Handle semver versions
-    const semverVersions = candidates.filter((c) => c.version.match(/^\d+\.\d+\.\d+/));
     if (semverVersions.length === 0) {
-        return candidates[0]; // Fallback to any available version
+        // No semver versions, return first non-semver if available
+        return nonSemverVersions.length > 0 ? nonSemverVersions[0].version : null;
     }
     // Find all versions that satisfy the spec
     const satisfyingVersions = semverVersions.filter((candidate) => {
@@ -940,17 +915,14 @@ function findBestVersionMatch(packageName, versionSpec, candidates) {
         }
     });
     if (satisfyingVersions.length === 0) {
-        // No satisfying versions found, return the first candidate as fallback
-        return semverVersions[0];
+        // No satisfying versions found, return the first semver candidate as fallback
+        return semverVersions[0].version;
     }
     // Return the highest satisfying version (similar to npm behavior)
     // Sort versions in descending order and return the first one
     const sortedVersions = satisfyingVersions.sort((a, b) => {
         try {
-            // Use semver comparison if possible
-            const aVersion = a.version.match(/^\d+\.\d+\.\d+/) ? a.version : '0.0.0';
-            const bVersion = b.version.match(/^\d+\.\d+\.\d+/) ? b.version : '0.0.0';
-            return aVersion.localeCompare(bVersion, undefined, {
+            return b.version.localeCompare(a.version, undefined, {
                 numeric: true,
                 sensitivity: 'base',
             });
@@ -960,5 +932,5 @@ function findBestVersionMatch(packageName, versionSpec, candidates) {
             return b.version.localeCompare(a.version);
         }
     });
-    return sortedVersions[0];
+    return sortedVersions[0].version;
 }