dnx_core/

linker.rs

use crate::cache::ContentCache;
use crate::errors::{DnxError, Result};
use crate::resolver::{DependencyGraph, ResolvedPackage};
use crate::workspace::Workspace;
use rayon::prelude::*;
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::Arc;
use walkdir::WalkDir;

/// Global flag: is reflink supported on this filesystem?
/// Starts as true, set to false after first failed attempt.
static REFLINK_SUPPORTED: AtomicBool = AtomicBool::new(true);

/// Global flag: has the NTFS hardlink limit warning been shown?
#[cfg(windows)]
static NTFS_LIMIT_WARNED: AtomicBool = AtomicBool::new(false);

/// Global counter: number of files that fell back to copy due to hardlink limits.
#[cfg(windows)]
static COPY_FALLBACK_COUNT: AtomicUsize = AtomicUsize::new(0);

#[derive(Debug, Default, Serialize, Deserialize)]
pub struct LinkStats {
    pub linked: usize,
    pub hardlinks: usize,
    pub symlinks: usize,
}

/// Shared progress counter that can be polled from another thread.
/// The linker increments `completed` atomically as packages are linked.
pub struct LinkProgress {
    pub total: AtomicUsize,
    pub completed: AtomicUsize,
}

impl LinkProgress {
    pub fn new() -> Arc<Self> {
        Arc::new(Self {
            total: AtomicUsize::new(0),
            completed: AtomicUsize::new(0),
        })
    }
}

#[derive(Debug, Default)]
pub struct ScriptStats {
    pub ran: usize,
    pub failed: usize,
    pub skipped: usize,
}

pub struct Linker {
    cache: Arc<ContentCache>,
    project_root: PathBuf,
    shamefully_hoist: bool,
    hoist: bool,
    hoist_pattern: Vec<String>,
    public_hoist_pattern: Vec<String>,
}

/// Validate that a package name doesn't contain path traversal
fn validate_package_name(name: &str) -> Result<()> {
    if name.contains("..") || name.contains("\\") || (name.contains('/') && !name.starts_with('@'))
    {
        return Err(DnxError::Linker(format!(
            "Invalid package name (potential path traversal): {}",
            name
        )));
    }
    // Scoped packages: validate scope and name parts
    if name.starts_with('@') {
        let parts: Vec<&str> = name.splitn(2, '/').collect();
        if parts.len() != 2 || parts[0].len() <= 1 || parts[1].is_empty() {
            return Err(DnxError::Linker(format!(
                "Invalid scoped package name: {}",
                name
            )));
        }
        if parts[0].contains("..") || parts[1].contains("..") || parts[1].contains('/') {
            return Err(DnxError::Linker(format!(
                "Invalid scoped package name (potential path traversal): {}",
                name
            )));
        }
    }
    Ok(())
}

/// Validate a bin entry name/path against path traversal
fn validate_bin_entry(name: &str, path: &str) -> Result<()> {
    if name.contains("..") || name.contains('/') || name.contains('\\') {
        return Err(DnxError::Linker(format!(
            "Invalid bin name (potential path traversal): {}",
            name
        )));
    }
    if path.contains("..") {
        return Err(DnxError::Linker(format!(
            "Invalid bin path (potential path traversal): {}",
            path
        )));
    }
    Ok(())
}

impl Linker {
    pub fn new(cache: Arc<ContentCache>, project_root: PathBuf) -> Self {
        Self {
            cache,
            project_root,
            shamefully_hoist: false,
            hoist: true,
            hoist_pattern: vec!["*".to_string()],
            public_hoist_pattern: vec!["@types/*".to_string()],
        }
    }

    pub fn with_config(
        cache: Arc<ContentCache>,
        project_root: PathBuf,
        shamefully_hoist: bool,
        hoist: bool,
        hoist_pattern: Vec<String>,
        public_hoist_pattern: Vec<String>,
    ) -> Self {
        Self {
            cache,
            project_root,
            shamefully_hoist,
            hoist,
            hoist_pattern,
            public_hoist_pattern,
        }
    }

    /// Link packages from cache to node_modules using pnpm-style layout
    pub async fn link(&self, graph: &DependencyGraph, direct_deps: &[String]) -> Result<LinkStats> {
        self.link_with_progress(graph, direct_deps, None).await
    }

    /// Link packages with optional progress tracking.
    pub async fn link_with_progress(
        &self,
        graph: &DependencyGraph,
        direct_deps: &[String],
        progress: Option<Arc<LinkProgress>>,
    ) -> Result<LinkStats> {
        let mut stats = LinkStats::default();
        let node_modules = self.project_root.join("node_modules");
        let dnx_dir = node_modules.join(".dnx");

        // Warn if cache and project are on different volumes
        let cache_root = self.cache.content_dir();
        warn_cross_volume(&cache_root, &self.project_root);

        // Warn if project is in a cloud-synced directory
        warn_cloud_sync(&self.project_root);

        // Read existing manifest to determine what's already linked
        let old_manifest = PackagesManifest::read(&dnx_dir);

        // Build new manifest from the dependency graph
        let mut new_manifest = PackagesManifest::new();
        for pkg in &graph.packages {
            if pkg.version.starts_with("link:")
                || pkg.version.starts_with("file:")
                || pkg.version.starts_with("git+")
                || pkg.version.starts_with("github:")
                || pkg.version.starts_with("workspace:")
            {
                continue;
            }
            let pkg_key = format!("{}@{}", pkg.name, pkg.version);
            new_manifest.packages.insert(pkg_key, pkg.integrity.clone());
        }

        // Compute diff: remove stale packages, identify packages to add
        let stale_keys: Vec<String> = old_manifest
            .packages
            .keys()
            .filter(|k| !new_manifest.packages.contains_key(*k))
            .cloned()
            .collect();

        for key in &stale_keys {
            let stale_dir = dnx_dir.join(key);
            match std::fs::remove_dir_all(&stale_dir) {
                Ok(()) => {}
                Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
                Err(e) => {
                    tracing::warn!("Failed to remove stale package {}: {}", key, e);
                }
            }
        }

        // Create node_modules/.dnx directory
        std::fs::create_dir_all(&dnx_dir)
            .map_err(|e| DnxError::Io(format!("Failed to create .dnx directory: {}", e)))?;

        // Build a lookup map for package versions
        let pkg_map: HashMap<String, &ResolvedPackage> = graph
            .packages
            .iter()
            .map(|pkg| (pkg.name.clone(), pkg))
            .collect();

        // Step 1: Link all packages to virtual store (parallel)
        // Validate all names first (sequential — fast, and avoids partial work on error)
        for pkg in &graph.packages {
            validate_package_name(&pkg.name)?;
        }

        let total_hardlinks = AtomicUsize::new(0);
        let total_linked = AtomicUsize::new(0);

        // Set total count on progress tracker
        if let Some(ref p) = progress {
            p.total.store(graph.packages.len(), Ordering::Relaxed);
        }

        let link_results: std::result::Result<Vec<()>, DnxError> = graph
            .packages
            .par_iter()
            .map(|pkg| {
                // Skip link:/file:/git+ packages — they don't come from cache
                if pkg.version.starts_with("link:")
                    || pkg.version.starts_with("file:")
                    || pkg.version.starts_with("git+")
                    || pkg.version.starts_with("github:")
                {
                    total_linked.fetch_add(1, Ordering::Relaxed);
                    if let Some(ref p) = progress {
                        p.completed.fetch_add(1, Ordering::Relaxed);
                    }
                    return Ok(());
                }

                let pkg_key = format!("{}@{}", pkg.name, pkg.version);

                // Skip if already linked with same integrity (incremental)
                if let Some(old_integrity) = old_manifest.packages.get(&pkg_key) {
                    if old_integrity == &pkg.integrity {
                        let virtual_pkg_dir =
                            dnx_dir.join(&pkg_key).join("node_modules").join(&pkg.name);
                        if virtual_pkg_dir.exists() {
                            total_linked.fetch_add(1, Ordering::Relaxed);
                            if let Some(ref p) = progress {
                                p.completed.fetch_add(1, Ordering::Relaxed);
                            }
                            return Ok(());
                        }
                    }
                }

                let virtual_pkg_dir = dnx_dir.join(&pkg_key).join("node_modules").join(&pkg.name);

                // Create the virtual package directory
                std::fs::create_dir_all(&virtual_pkg_dir).map_err(|e| {
                    DnxError::Io(format!(
                        "Failed to create virtual directory for {}: {}",
                        pkg_key, e
                    ))
                })?;

                // Get cached package path
                let cached_path = self.cache.get_path(&pkg.integrity);

                if !cached_path.exists() {
                    return Err(DnxError::Linker(format!(
                        "Package {} not found in cache at {}",
                        pkg_key,
                        cached_path.display()
                    )));
                }

                // Hardlink files from cache to virtual store
                let (hardlinks, copies) = hardlink_dir(&cached_path, &virtual_pkg_dir)?;
                total_hardlinks.fetch_add(hardlinks, Ordering::Relaxed);
                total_linked.fetch_add(1, Ordering::Relaxed);
                if let Some(ref p) = progress {
                    p.completed.fetch_add(1, Ordering::Relaxed);
                }

                if copies > 0 {
                    eprintln!(
                        "Warning: {} files copied instead of hardlinked for {}",
                        copies, pkg_key
                    );
                }

                Ok(())
            })
            .collect();

        link_results?;
        stats.hardlinks = total_hardlinks.load(Ordering::Relaxed);
        stats.linked = total_linked.load(Ordering::Relaxed);

        // Step 2: Create symlinks for dependencies (including peers) in virtual store
        // Collect all symlink pairs first, then create in parallel
        let mut symlink_pairs: Vec<(PathBuf, PathBuf)> = Vec::new();
        let mut scope_dirs: HashSet<PathBuf> = HashSet::new();

        for pkg in &graph.packages {
            let pkg_key = format!("{}@{}", pkg.name, pkg.version);
            let virtual_node_modules = dnx_dir.join(&pkg_key).join("node_modules");

            let all_deps = pkg.dependencies.iter().chain(pkg.peer_dependencies.iter());
            for dep in all_deps {
                let (dep_name, dep_version) = if let Some(stripped) = dep.strip_prefix('@') {
                    if let Some(idx) = stripped.find('@') {
                        (&dep[..idx + 1], &stripped[idx + 1..])
                    } else {
                        continue;
                    }
                } else if let Some(idx) = dep.find('@') {
                    (&dep[..idx], &dep[idx + 1..])
                } else {
                    continue;
                };

                let dep_key = format!("{}@{}", dep_name, dep_version);
                let target = dnx_dir.join(&dep_key).join("node_modules").join(dep_name);
                let link = virtual_node_modules.join(dep_name);

                if dep_name.contains('/') {
                    if let Some(parent) = link.parent() {
                        scope_dirs.insert(parent.to_path_buf());
                    }
                }

                symlink_pairs.push((target, link));
            }
        }

        // Create scope directories sequentially (fast, few entries)
        for dir in &scope_dirs {
            std::fs::create_dir_all(dir)
                .map_err(|e| DnxError::Io(format!("Failed to create scope directory: {}", e)))?;
        }

        // Create symlinks in parallel
        let symlink_count = AtomicUsize::new(0);
        let symlink_results: std::result::Result<Vec<()>, DnxError> = symlink_pairs
            .par_iter()
            .map(|(target, link)| {
                // Skip if link already exists and points to correct target
                if link.symlink_metadata().is_ok() {
                    if let Ok(existing_target) = std::fs::read_link(link) {
                        if existing_target == *target {
                            return Ok(());
                        }
                    }
                    return Ok(()); // exists but different — don't overwrite dep symlinks
                }
                create_symlink_or_junction(target, link)?;
                symlink_count.fetch_add(1, Ordering::Relaxed);
                Ok(())
            })
            .collect();
        symlink_results?;
        stats.symlinks += symlink_count.load(Ordering::Relaxed);

        // Step 3: Create symlinks for direct dependencies in root node_modules
        for dep_name in direct_deps {
            let pkg = pkg_map.get(dep_name).ok_or_else(|| {
                DnxError::Linker(format!("Direct dependency {} not found in graph", dep_name))
            })?;

            // For link: dependencies, symlink directly to the local path
            let target = if pkg.version.starts_with("link:") {
                let link_path = &pkg.version[5..];
                let abs_path = if std::path::Path::new(link_path).is_absolute() {
                    PathBuf::from(link_path)
                } else {
                    self.project_root.join(link_path)
                };
                abs_path
            } else {
                let pkg_key = format!("{}@{}", pkg.name, pkg.version);
                dnx_dir.join(&pkg_key).join("node_modules").join(&pkg.name)
            };

            // Link: node_modules/<name>
            let link = node_modules.join(&pkg.name);

            // Create parent directory for scoped packages
            if pkg.name.contains('/') {
                if let Some(parent) = link.parent() {
                    std::fs::create_dir_all(parent).map_err(|e| {
                        DnxError::Io(format!(
                            "Failed to create scope directory for {}: {}",
                            pkg.name, e
                        ))
                    })?;
                }
            }

            // Skip if existing symlink/junction already points to correct target
            if link.symlink_metadata().is_ok() {
                if let Ok(existing_target) = std::fs::read_link(&link) {
                    if existing_target == target {
                        continue;
                    }
                }
                // Exists but points elsewhere — remove it
                match std::fs::remove_dir_all(&link) {
                    Ok(()) => {}
                    Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
                    Err(e) => {
                        return Err(DnxError::Linker(format!(
                            "Failed to remove stale symlink {}: {}",
                            link.display(),
                            e
                        )));
                    }
                }
            }

            // Atomic symlink: create at a temp name then rename over the target.
            // On Windows junctions can't be atomically renamed, so we use retry logic.
            #[cfg(unix)]
            {
                let temp_link = link.with_extension(".dnx-tmp");
                let _ = std::fs::remove_file(&temp_link);
                create_symlink_or_junction(&target, &temp_link)?;
                if let Err(e) = std::fs::rename(&temp_link, &link) {
                    let _ = std::fs::remove_file(&temp_link);
                    return Err(DnxError::Linker(format!(
                        "Failed to atomically place symlink {}: {}",
                        link.display(),
                        e
                    )));
                }
            }
            #[cfg(not(unix))]
            {
                create_symlink_or_junction_with_retry(&target, &link)?;
            }
            stats.symlinks += 1;
        }

        // Step 4: Create .bin directory and bin scripts
        let bin_dir = node_modules.join(".bin");
        std::fs::create_dir_all(&bin_dir)
            .map_err(|e| DnxError::Io(format!("Failed to create .bin directory: {}", e)))?;

        for pkg in &graph.packages {
            let pkg_key = format!("{}@{}", pkg.name, pkg.version);
            let pkg_path = dnx_dir.join(&pkg_key).join("node_modules").join(&pkg.name);

            let bin = if pkg.bin.is_empty() {
                // Fallback: read bin from cached package.json (for old lockfiles)
                extract_bin_from_package_json(&pkg_path)
            } else {
                pkg.bin.clone()
            };

            if !bin.is_empty() {
                let synthetic = ResolvedPackage {
                    name: pkg.name.clone(),
                    version: pkg.version.clone(),
                    tarball_url: String::new(),
                    integrity: String::new(),
                    dependencies: Vec::new(),
                    peer_dependencies: Vec::new(),
                    bin,
                    has_install_script: false,
                };
                create_bin_scripts(&bin_dir, &synthetic, &pkg_path)?;
            }
        }

        // Write packages manifest for incremental linking
        new_manifest.write(&dnx_dir);

        Ok(stats)
    }

    /// Link packages in a workspace layout.
    ///
    /// 1. Hardlinks all external packages from cache into `root/node_modules/.dnx/`.
    /// 2. Symlinks all workspace members at `root/node_modules/<member_name>`.
    /// 3. For each member, creates `<member>/node_modules/` with symlinks to
    ///    workspace siblings and external deps.
    pub async fn link_workspace(
        &self,
        graph: &DependencyGraph,
        workspace: &Workspace,
    ) -> Result<LinkStats> {
        self.link_workspace_with_progress(graph, workspace, None)
            .await
    }

    pub async fn link_workspace_with_progress(
        &self,
        graph: &DependencyGraph,
        workspace: &Workspace,
        progress: Option<Arc<LinkProgress>>,
    ) -> Result<LinkStats> {
        let mut stats = LinkStats::default();
        let node_modules = self.project_root.join("node_modules");
        let dnx_dir = node_modules.join(".dnx");

        // Warn if cache and project are on different volumes
        let cache_root = self.cache.content_dir();
        warn_cross_volume(&cache_root, &self.project_root);

        // Warn if project is in a cloud-synced directory
        warn_cloud_sync(&self.project_root);

        // Read existing manifest for incremental linking
        let old_manifest = PackagesManifest::read(&dnx_dir);

        // Build new manifest
        let mut new_manifest = PackagesManifest::new();
        for pkg in &graph.packages {
            if pkg.version.starts_with("workspace:")
                || pkg.version.starts_with("link:")
                || pkg.version.starts_with("file:")
                || pkg.version.starts_with("git+")
                || pkg.version.starts_with("github:")
            {
                continue;
            }
            let pkg_key = format!("{}@{}", pkg.name, pkg.version);
            new_manifest.packages.insert(pkg_key, pkg.integrity.clone());
        }

        // Remove stale packages
        let stale_keys: Vec<String> = old_manifest
            .packages
            .keys()
            .filter(|k| !new_manifest.packages.contains_key(*k))
            .cloned()
            .collect();

        for key in &stale_keys {
            let stale_dir = dnx_dir.join(key);
            match std::fs::remove_dir_all(&stale_dir) {
                Ok(()) => {}
                Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
                Err(e) => {
                    tracing::warn!("Failed to remove stale package {}: {}", key, e);
                }
            }
        }

        std::fs::create_dir_all(&dnx_dir)
            .map_err(|e| DnxError::Io(format!("Failed to create .dnx directory: {}", e)))?;

        // Build package lookup map
        let pkg_map: HashMap<String, &ResolvedPackage> = graph
            .packages
            .iter()
            .map(|pkg| (pkg.name.clone(), pkg))
            .collect();

        // Validate all names
        for pkg in &graph.packages {
            validate_package_name(&pkg.name)?;
        }

        // Step 1: Link all external packages to virtual store (parallel)
        let total_hardlinks = AtomicUsize::new(0);
        let total_linked = AtomicUsize::new(0);

        // Set total count on progress tracker
        if let Some(ref p) = progress {
            let external_count = graph
                .packages
                .iter()
                .filter(|pkg| {
                    !pkg.version.starts_with("workspace:")
                        && !pkg.version.starts_with("link:")
                        && !pkg.version.starts_with("file:")
                        && !pkg.version.starts_with("git+")
                        && !pkg.version.starts_with("github:")
                })
                .count();
            p.total.store(external_count, Ordering::Relaxed);
        }

        let link_results: std::result::Result<Vec<()>, DnxError> = graph
            .packages
            .par_iter()
            .filter(|pkg| {
                !pkg.version.starts_with("workspace:")
                    && !pkg.version.starts_with("link:")
                    && !pkg.version.starts_with("file:")
                    && !pkg.version.starts_with("git+")
                    && !pkg.version.starts_with("github:")
            })
            .map(|pkg| {
                let pkg_key = format!("{}@{}", pkg.name, pkg.version);

                // Skip if already linked with same integrity (incremental)
                if let Some(old_integrity) = old_manifest.packages.get(&pkg_key) {
                    if old_integrity == &pkg.integrity {
                        let virtual_pkg_dir =
                            dnx_dir.join(&pkg_key).join("node_modules").join(&pkg.name);
                        if virtual_pkg_dir.exists() {
                            total_linked.fetch_add(1, Ordering::Relaxed);
                            if let Some(ref p) = progress {
                                p.completed.fetch_add(1, Ordering::Relaxed);
                            }
                            return Ok(());
                        }
                    }
                }

                let virtual_pkg_dir = dnx_dir.join(&pkg_key).join("node_modules").join(&pkg.name);

                std::fs::create_dir_all(&virtual_pkg_dir).map_err(|e| {
                    DnxError::Io(format!(
                        "Failed to create virtual directory for {}: {}",
                        pkg_key, e
                    ))
                })?;

                let cached_path = self.cache.get_path(&pkg.integrity);
                if !cached_path.exists() {
                    return Err(DnxError::Linker(format!(
                        "Package {} not found in cache at {}",
                        pkg_key,
                        cached_path.display()
                    )));
                }

                let (hardlinks, _copies) = hardlink_dir(&cached_path, &virtual_pkg_dir)?;
                total_hardlinks.fetch_add(hardlinks, Ordering::Relaxed);
                total_linked.fetch_add(1, Ordering::Relaxed);
                if let Some(ref p) = progress {
                    p.completed.fetch_add(1, Ordering::Relaxed);
                }
                Ok(())
            })
            .collect();

        link_results?;
        stats.hardlinks = total_hardlinks.load(Ordering::Relaxed);
        stats.linked = total_linked.load(Ordering::Relaxed);

        // Step 2: Create symlinks for dependencies in virtual store (parallel)
        let mut ws_symlink_pairs: Vec<(PathBuf, PathBuf)> = Vec::new();
        let mut ws_scope_dirs: HashSet<PathBuf> = HashSet::new();

        for pkg in &graph.packages {
            if pkg.version.starts_with("workspace:") {
                continue;
            }
            let pkg_key = format!("{}@{}", pkg.name, pkg.version);
            let virtual_node_modules = dnx_dir.join(&pkg_key).join("node_modules");

            let all_deps = pkg.dependencies.iter().chain(pkg.peer_dependencies.iter());
            for dep in all_deps {
                let (dep_name, dep_version) = parse_dep_ref(dep);
                if dep_name.is_empty() {
                    continue;
                }

                let dep_key = format!("{}@{}", dep_name, dep_version);
                let target = dnx_dir.join(&dep_key).join("node_modules").join(dep_name);
                let link = virtual_node_modules.join(dep_name);

                if dep_name.contains('/') {
                    if let Some(parent) = link.parent() {
                        ws_scope_dirs.insert(parent.to_path_buf());
                    }
                }

                ws_symlink_pairs.push((target, link));
            }
        }

        for dir in &ws_scope_dirs {
            std::fs::create_dir_all(dir)
                .map_err(|e| DnxError::Io(format!("Failed to create scope directory: {}", e)))?;
        }

        let ws_symlink_count = AtomicUsize::new(0);
        let ws_symlink_results: std::result::Result<Vec<()>, DnxError> = ws_symlink_pairs
            .par_iter()
            .map(|(target, link)| {
                if link.symlink_metadata().is_ok() {
                    if let Ok(existing_target) = std::fs::read_link(link) {
                        if existing_target == *target {
                            return Ok(());
                        }
                    }
                    return Ok(());
                }
                create_symlink_or_junction(target, link)?;
                ws_symlink_count.fetch_add(1, Ordering::Relaxed);
                Ok(())
            })
            .collect();
        ws_symlink_results?;
        stats.symlinks += ws_symlink_count.load(Ordering::Relaxed);

        // Step 3: Symlink all workspace members at root/node_modules/<name>
        for (name, member) in &workspace.members {
            let link = node_modules.join(name);

            if name.contains('/') {
                if let Some(parent) = link.parent() {
                    std::fs::create_dir_all(parent).map_err(|e| {
                        DnxError::Io(format!(
                            "Failed to create scope directory for {}: {}",
                            name, e
                        ))
                    })?;
                }
            }

            if link.symlink_metadata().is_ok() {
                if let Ok(existing_target) = std::fs::read_link(&link) {
                    if existing_target == member.path {
                        continue;
                    }
                }
                let _ = std::fs::remove_dir_all(&link);
            }

            create_symlink_or_junction(&member.path, &link)?;
            stats.symlinks += 1;
        }

        // Step 4: Per-member node_modules
        for (name, member) in &workspace.members {
            let member_nm = member.path.join("node_modules");
            std::fs::create_dir_all(&member_nm).map_err(|e| {
                DnxError::Io(format!("Failed to create node_modules for {}: {}", name, e))
            })?;

            let all_deps = member.package_json.all_dependencies();
            for (dep_name, dep_spec) in &all_deps {
                let link = member_nm.join(dep_name);

                if dep_name.contains('/') {
                    if let Some(parent) = link.parent() {
                        std::fs::create_dir_all(parent).map_err(|e| {
                            DnxError::Io(format!(
                                "Failed to create scope dir for {}: {}",
                                dep_name, e
                            ))
                        })?;
                    }
                }

                if link.exists() || link.symlink_metadata().is_ok() {
                    continue;
                }

                // Is this a workspace dep?
                if dep_spec.starts_with("workspace:") || workspace.members.contains_key(dep_name) {
                    if let Some(dep_member) = workspace.members.get(dep_name) {
                        create_symlink_or_junction(&dep_member.path, &link)?;
                        stats.symlinks += 1;
                    }
                } else {
                    // External dep — link to virtual store
                    if let Some(pkg) = pkg_map.get(dep_name) {
                        if !pkg.version.starts_with("workspace:") {
                            let pkg_key = format!("{}@{}", pkg.name, pkg.version);
                            let target =
                                dnx_dir.join(&pkg_key).join("node_modules").join(&pkg.name);
                            create_symlink_or_junction(&target, &link)?;
                            stats.symlinks += 1;
                        }
                    }
                }
            }

            // Create .bin directory for member
            let member_bin_dir = member_nm.join(".bin");
            std::fs::create_dir_all(&member_bin_dir).map_err(|e| {
                DnxError::Io(format!("Failed to create .bin dir for {}: {}", name, e))
            })?;
        }

        // Step 5: Create root .bin directory
        let bin_dir = node_modules.join(".bin");
        std::fs::create_dir_all(&bin_dir)
            .map_err(|e| DnxError::Io(format!("Failed to create .bin directory: {}", e)))?;

        for pkg in &graph.packages {
            if pkg.version.starts_with("workspace:") {
                continue;
            }
            let pkg_key = format!("{}@{}", pkg.name, pkg.version);
            let pkg_path = dnx_dir.join(&pkg_key).join("node_modules").join(&pkg.name);

            let bin = if pkg.bin.is_empty() {
                extract_bin_from_package_json(&pkg_path)
            } else {
                pkg.bin.clone()
            };

            if !bin.is_empty() {
                let synthetic = ResolvedPackage {
                    name: pkg.name.clone(),
                    version: pkg.version.clone(),
                    tarball_url: String::new(),
                    integrity: String::new(),
                    dependencies: Vec::new(),
                    peer_dependencies: Vec::new(),
                    bin,
                    has_install_script: false,
                };
                create_bin_scripts(&bin_dir, &synthetic, &pkg_path)?;
            }
        }

        stats.linked += workspace.members.len();

        // Write packages manifest for incremental linking
        new_manifest.write(&dnx_dir);

        Ok(stats)
    }

    /// Write link state file so subsequent installs can skip linking
    /// if the lockfile hasn't changed.
    pub fn write_state(&self, lockfile_hash: &str) -> Result<()> {
        let state_dir = self.project_root.join("node_modules").join(".dnx");
        std::fs::create_dir_all(&state_dir)
            .map_err(|e| DnxError::Io(format!("Failed to create .dnx directory: {}", e)))?;

        let state = serde_json::json!({ "lockfileHash": lockfile_hash });
        let state_path = state_dir.join("state.json");
        std::fs::write(&state_path, state.to_string())
            .map_err(|e| DnxError::Io(format!("Failed to write state file: {}", e)))?;
        Ok(())
    }

    /// Check if the link state matches the given lockfile hash.
    pub fn check_state(&self, lockfile_hash: &str) -> bool {
        let state_path = self
            .project_root
            .join("node_modules")
            .join(".dnx")
            .join("state.json");
        let content = match std::fs::read_to_string(&state_path) {
            Ok(c) => c,
            Err(_) => return false,
        };
        let json: serde_json::Value = match serde_json::from_str(&content) {
            Ok(v) => v,
            Err(_) => return false,
        };
        json.get("lockfileHash")
            .and_then(|v| v.as_str())
            .map(|h| h == lockfile_hash)
            .unwrap_or(false)
    }

    /// Run install scripts (preinstall, install, postinstall) for packages that declare them.
    /// Uses rayon for parallel execution across packages, but runs scripts sequentially per package.
    pub fn run_install_scripts(&self, graph: &DependencyGraph) -> ScriptStats {
        let node_modules = self.project_root.join("node_modules");
        let dnx_dir = node_modules.join(".dnx");
        let bin_dir = node_modules.join(".bin");

        let packages_with_scripts: Vec<&ResolvedPackage> = graph
            .packages
            .iter()
            .filter(|pkg| {
                pkg.has_install_script
                    && !pkg.version.starts_with("link:")
                    && !pkg.version.starts_with("file:")
                    && !pkg.version.starts_with("git+")
                    && !pkg.version.starts_with("github:")
                    && !pkg.version.starts_with("workspace:")
            })
            .collect();

        if packages_with_scripts.is_empty() {
            return ScriptStats {
                ran: 0,
                failed: 0,
                skipped: 0,
            };
        }

        let ran = AtomicUsize::new(0);
        let failed = AtomicUsize::new(0);
        let skipped = AtomicUsize::new(0);

        packages_with_scripts.par_iter().for_each(|pkg| {
            let pkg_key = format!("{}@{}", pkg.name, pkg.version);
            let pkg_path = dnx_dir
                .join(&pkg_key)
                .join("node_modules")
                .join(&pkg.name);

            let pkg_json_path = pkg_path.join("package.json");
            if !pkg_json_path.exists() {
                skipped.fetch_add(1, Ordering::Relaxed);
                return;
            }

            // Read package.json to get the actual script contents
            let content = match std::fs::read_to_string(&pkg_json_path) {
                Ok(c) => c,
                Err(_) => {
                    skipped.fetch_add(1, Ordering::Relaxed);
                    return;
                }
            };
            let json: serde_json::Value = match serde_json::from_str(&content) {
                Ok(v) => v,
                Err(_) => {
                    skipped.fetch_add(1, Ordering::Relaxed);
                    return;
                }
            };

            let scripts = match json.get("scripts").and_then(|s| s.as_object()) {
                Some(s) => s,
                None => {
                    skipped.fetch_add(1, Ordering::Relaxed);
                    return;
                }
            };

            let has_any = scripts.contains_key("preinstall")
                || scripts.contains_key("install")
                || scripts.contains_key("postinstall");

            if !has_any {
                skipped.fetch_add(1, Ordering::Relaxed);
                return;
            }

            // Build PATH with .bin directory
            let current_path = std::env::var("PATH").unwrap_or_default();
            let path_sep = if cfg!(windows) { ";" } else { ":" };
            let new_path = format!("{}{}{}", bin_dir.to_string_lossy(), path_sep, current_path);

            let pkg_name = json.get("name").and_then(|v| v.as_str()).unwrap_or(&pkg.name);
            let pkg_version = json.get("version").and_then(|v| v.as_str()).unwrap_or(&pkg.version);

            // Determine if this is an optional dependency (failures are non-fatal)
            let is_optional = pkg.dependencies.iter().any(|d| d.contains("optional"));

            // Run preinstall → install → postinstall sequentially
            for script_name in &["preinstall", "install", "postinstall"] {
                if let Some(script_content) = scripts.get(*script_name).and_then(|v| v.as_str()) {
                    if script_content.is_empty() {
                        continue;
                    }

                    let mut cmd = if cfg!(windows) {
                        let mut c = std::process::Command::new("cmd.exe");
                        c.args(["/C", script_content]);
                        c
                    } else {
                        let mut c = std::process::Command::new("/bin/sh");
                        c.args(["-c", script_content]);
                        c
                    };

                    cmd.current_dir(&pkg_path)
                        .env("PATH", &new_path)
                        .env("npm_lifecycle_event", *script_name)
                        .env("npm_package_name", pkg_name)
                        .env("npm_package_version", pkg_version)
                        .stdout(std::process::Stdio::piped())
                        .stderr(std::process::Stdio::piped());

                    match cmd.status() {
                        Ok(status) if status.success() => {
                            // Script succeeded
                        }
                        Ok(_) | Err(_) => {
                            if is_optional {
                                eprintln!(
                                    "\x1b[33m⚠  Optional script {} for {} failed, continuing\x1b[0m",
                                    script_name, pkg_key
                                );
                            } else {
                                eprintln!(
                                    "\x1b[33m⚠  Script {} for {} failed\x1b[0m",
                                    script_name, pkg_key
                                );
                            }
                            failed.fetch_add(1, Ordering::Relaxed);
                            return; // Don't run subsequent scripts for this package
                        }
                    }
                }
            }

            ran.fetch_add(1, Ordering::Relaxed);
        });

        ScriptStats {
            ran: ran.load(Ordering::Relaxed),
            failed: failed.load(Ordering::Relaxed),
            skipped: skipped.load(Ordering::Relaxed),
        }
    }

    /// Hoist packages according to configuration.
    /// - shamefully_hoist: hoist ALL packages to root node_modules (flat layout like npm)
    /// - hoist: hoist matching packages to node_modules/.dnx/node_modules (hidden hoisting)
    /// - public_hoist_pattern: hoist matching packages to root node_modules
    pub fn hoist_packages(&self, graph: &DependencyGraph, direct_deps: &[String]) -> Result<usize> {
        let node_modules = self.project_root.join("node_modules");
        let mut hoisted = 0usize;

        if self.shamefully_hoist {
            // Flat layout: symlink ALL packages to root node_modules
            for pkg in &graph.packages {
                let pkg_key = format!("{}@{}", pkg.name, pkg.version);
                let source = node_modules
                    .join(".dnx")
                    .join(&pkg_key)
                    .join("node_modules")
                    .join(&pkg.name);

                if !source.exists() {
                    continue;
                }

                let target = node_modules.join(&pkg.name);

                // Skip if already a direct dep (already linked)
                if direct_deps.contains(&pkg.name) {
                    continue;
                }

                // Create parent dir for scoped packages
                if pkg.name.contains('/') {
                    if let Some(parent) = target.parent() {
                        let _ = std::fs::create_dir_all(parent);
                    }
                }

                // Skip if target already exists
                if target.exists() || target.symlink_metadata().is_ok() {
                    continue;
                }

                // Create symlink
                if create_symlink_or_junction(&source, &target).is_ok() {
                    hoisted += 1;
                }
            }
        } else if self.hoist {
            // Hidden hoisting: symlink to node_modules/.dnx/node_modules
            let hoist_dir = node_modules.join(".dnx").join("node_modules");
            let _ = std::fs::create_dir_all(&hoist_dir);

            for pkg in &graph.packages {
                if !self.matches_pattern(&pkg.name, &self.hoist_pattern) {
                    continue;
                }

                let pkg_key = format!("{}@{}", pkg.name, pkg.version);
                let source = node_modules
                    .join(".dnx")
                    .join(&pkg_key)
                    .join("node_modules")
                    .join(&pkg.name);

                if !source.exists() {
                    continue;
                }

                let target = hoist_dir.join(&pkg.name);
                if pkg.name.contains('/') {
                    if let Some(parent) = target.parent() {
                        let _ = std::fs::create_dir_all(parent);
                    }
                }

                if !target.exists() && create_symlink_or_junction(&source, &target).is_ok() {
                    hoisted += 1;
                }
            }

            // Public hoisting: hoist @types/* etc to root node_modules
            for pkg in &graph.packages {
                if !self.matches_pattern(&pkg.name, &self.public_hoist_pattern) {
                    continue;
                }
                if direct_deps.contains(&pkg.name) {
                    continue;
                }

                let pkg_key = format!("{}@{}", pkg.name, pkg.version);
                let source = node_modules
                    .join(".dnx")
                    .join(&pkg_key)
                    .join("node_modules")
                    .join(&pkg.name);

                if !source.exists() {
                    continue;
                }

                let target = node_modules.join(&pkg.name);
                if pkg.name.contains('/') {
                    if let Some(parent) = target.parent() {
                        let _ = std::fs::create_dir_all(parent);
                    }
                }

                if !target.exists()
                    && target.symlink_metadata().is_err()
                    && create_symlink_or_junction(&source, &target).is_ok()
                {
                    hoisted += 1;
                }
            }
        }

        Ok(hoisted)
    }

    /// Check if a package name matches any of the given glob patterns.
    fn matches_pattern(&self, name: &str, patterns: &[String]) -> bool {
        for pattern in patterns {
            if pattern == "*" {
                return true;
            }
            // Simple glob matching: support "*" and "prefix/*"
            if let Some(prefix) = pattern.strip_suffix("/*") {
                if name.starts_with(&format!("{}/", prefix)) {
                    return true;
                }
            } else if pattern == name {
                return true;
            }
        }
        false
    }

    /// Unlink specified packages from node_modules root
    pub async fn unlink(&self, packages: &[String]) -> Result<()> {
        let node_modules = self.project_root.join("node_modules");

        for pkg_name in packages {
            let link = node_modules.join(pkg_name);

            if link.exists() || link.symlink_metadata().is_ok() {
                std::fs::remove_dir_all(&link)
                    .map_err(|e| DnxError::Io(format!("Failed to unlink {}: {}", pkg_name, e)))?;
            }
        }

        Ok(())
    }
}

/// Create a symlink or junction (Windows fallback)
///
/// On Windows, always prefer junctions (NTFS reparse points with absolute paths).
/// Junctions don't require Developer Mode or elevation and — crucially — use
/// absolute paths that Node.js ESM resolution follows correctly. Relative
/// directory symlinks (SYMLINKD) can break ESM `import` resolution on Windows
/// because Node.js `realpath` doesn't always resolve them the same way as CJS.
fn create_symlink_or_junction(target: &Path, link: &Path) -> Result<()> {
    #[cfg(windows)]
    {
        // Always use junctions on Windows — they work without elevation and
        // use absolute paths which Node.js ESM resolves correctly.
        let target_abs = if target.is_absolute() {
            // Canonicalize to resolve any .. or symlinks in the target path
            target
                .canonicalize()
                .unwrap_or_else(|_| target.to_path_buf())
        } else {
            let joined = link.parent().unwrap_or(Path::new(".")).join(target);
            joined.canonicalize().unwrap_or(joined)
        };

        junction::create(&target_abs, link).map_err(|e| {
            DnxError::Linker(format!(
                "Failed to create junction from {} to {}: {}",
                link.display(),
                target_abs.display(),
                e
            ))
        })?;
    }

    #[cfg(unix)]
    {
        std::os::unix::fs::symlink(target, link).map_err(|e| {
            DnxError::Io(format!(
                "Failed to create symlink from {} to {}: {}",
                link.display(),
                target.display(),
                e
            ))
        })?;
    }

    Ok(())
}

/// Windows-only: create a junction with retry logic for concurrent access.
/// Junctions can't be atomically renamed, so we remove + recreate with retries.
#[cfg(not(unix))]
fn create_symlink_or_junction_with_retry(target: &Path, link: &Path) -> Result<()> {
    const MAX_RETRIES: usize = 3;
    for attempt in 0..MAX_RETRIES {
        match create_symlink_or_junction(target, link) {
            Ok(()) => return Ok(()),
            Err(e) if attempt + 1 < MAX_RETRIES => {
                tracing::debug!(
                    "Junction creation attempt {} failed for {}: {}, retrying…",
                    attempt + 1,
                    link.display(),
                    e
                );
                // Brief sleep to let the other thread finish
                std::thread::sleep(std::time::Duration::from_millis(10));
                // Try to clean up before retrying
                match std::fs::remove_dir_all(link) {
                    Ok(()) => {}
                    Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
                    Err(_) => {}
                }
            }
            Err(e) => return Err(e),
        }
    }
    unreachable!()
}

/// Check if two paths are on the same filesystem/volume.
/// Returns true if same volume (hardlinks will work), false if different.
fn same_volume(path_a: &Path, path_b: &Path) -> bool {
    #[cfg(unix)]
    {
        use std::os::unix::fs::MetadataExt;
        let meta_a = std::fs::metadata(path_a);
        let meta_b = std::fs::metadata(path_b);
        match (meta_a, meta_b) {
            (Ok(a), Ok(b)) => a.dev() == b.dev(),
            _ => true, // Assume same volume if we can't check
        }
    }
    #[cfg(windows)]
    {
        // Try GetVolumePathNameW for accurate volume detection (handles UNC, mount points)
        fn get_volume_path(path: &Path) -> Option<String> {
            use std::os::windows::ffi::OsStrExt;
            let wide: Vec<u16> = path
                .as_os_str()
                .encode_wide()
                .chain(std::iter::once(0))
                .collect();
            let mut volume_path: Vec<u16> = vec![0u16; 260];

            extern "system" {
                fn GetVolumePathNameW(
                    lpszFileName: *const u16,
                    lpszVolumePathName: *mut u16,
                    cchBufferLength: u32,
                ) -> i32;
            }

            let result = unsafe {
                GetVolumePathNameW(
                    wide.as_ptr(),
                    volume_path.as_mut_ptr(),
                    volume_path.len() as u32,
                )
            };

            if result != 0 {
                let len = volume_path
                    .iter()
                    .position(|&c| c == 0)
                    .unwrap_or(volume_path.len());
                Some(String::from_utf16_lossy(&volume_path[..len]))
            } else {
                None
            }
        }

        // Try the accurate method first
        if let (Some(vol_a), Some(vol_b)) = (get_volume_path(path_a), get_volume_path(path_b)) {
            return vol_a.eq_ignore_ascii_case(&vol_b);
        }

        // Fallback to drive letter comparison
        let a_str = path_a.to_string_lossy();
        let b_str = path_b.to_string_lossy();
        let a_drive = a_str.chars().next();
        let b_drive = b_str.chars().next();
        match (a_drive, b_drive) {
            (Some(a), Some(b)) => a.eq_ignore_ascii_case(&b),
            _ => true,
        }
    }
    #[cfg(not(any(unix, windows)))]
    {
        let _ = (path_a, path_b);
        true
    }
}

/// Emit a one-time warning if cache and project are on different volumes.
fn warn_cross_volume(cache_path: &Path, project_path: &Path) {
    if !same_volume(cache_path, project_path) {
        let project_drive = project_path.to_string_lossy().chars().next().unwrap_or('C');

        eprintln!(
            "\x1b[33m⚠  Cache ({}) and project ({}) are on different volumes.\n   \
             Hardlinks will not work — falling back to file copies.\n   \
             Fix: set DNX_CACHE_DIR to a path on the same drive as your project:\n   \
             \x1b[1m  DNX_CACHE_DIR={}:/.dnx/cache dnx install\x1b[0m\x1b[33m\n   \
             Or add to dnx.toml: [settings] cache-dir = \"{}:/.dnx/cache\"\x1b[0m",
            cache_path.display(),
            project_path.display(),
            project_drive,
            project_drive,
        );
    }
}

/// Emit a one-time warning if the project is inside a cloud-synced directory
/// (OneDrive, Dropbox, iCloud Drive, Google Drive), which can severely slow down
/// installs due to file-level sync on every hardlink/copy.
fn warn_cloud_sync(project_path: &Path) {
    use std::sync::atomic::AtomicBool;
    static WARNED: AtomicBool = AtomicBool::new(false);

    if WARNED.load(Ordering::Relaxed) {
        return;
    }

    let path_str = project_path.to_string_lossy();
    let cloud_indicators = [
        "OneDrive",
        "Dropbox",
        "iCloud Drive",
        "Google Drive",
        "MEGA",
    ];

    for indicator in &cloud_indicators {
        if path_str.contains(indicator) {
            WARNED.store(true, Ordering::Relaxed);
            eprintln!(
                "\x1b[33m\u{26a0}  Project is inside {} — file sync may slow down installs.\n   \
                 Consider moving your project outside the synced folder, or excluding\n   \
                 node_modules from sync.\x1b[0m",
                indicator
            );
            return;
        }
    }
}

/// Try to import a file using the best available method:
/// 1. Reflink/clone (copy-on-write, supported on APFS, Btrfs, XFS) — skipped after first failure
/// 2. Hardlink (shares inode, zero extra disk usage)
/// 3. Regular copy (fallback)
///
/// Returns which method was used: 0 = reflink, 1 = hardlink, 2 = copy
fn import_file(src: &Path, dest: &Path) -> Result<u8> {
    // Try reflink first, but only if the filesystem supports it.
    // After the first failure we flip the flag so we never try again
    // (avoids thousands of failed syscalls on NTFS / ext4).
    if REFLINK_SUPPORTED.load(Ordering::Relaxed) {
        if reflink_copy::reflink(src, dest).is_ok() {
            return Ok(0);
        }
        // Filesystem doesn't support reflink — stop trying
        REFLINK_SUPPORTED.store(false, Ordering::Relaxed);
    }

    // Try hardlink
    match std::fs::hard_link(src, dest) {
        Ok(()) => return Ok(1),
        Err(e) => {
            // On Windows, detect ERROR_TOO_MANY_LINKS (1142) specifically
            #[cfg(windows)]
            {
                if let Some(code) = e.raw_os_error() {
                    if code == 1142 {
                        // NTFS max 1023 hardlinks reached — show one-time warning
                        COPY_FALLBACK_COUNT.fetch_add(1, Ordering::Relaxed);
                        if !NTFS_LIMIT_WARNED.swap(true, Ordering::Relaxed) {
                            eprintln!(
                                "\x1b[33m⚠  NTFS hardlink limit (1023) reached — falling back to copies for remaining files.\n   \
                                 Consider enabling Developer Mode for symlink support.\x1b[0m"
                            );
                        }
                        // Fall through to copy
                    }
                }
            }
            let _ = e;
        }
    }

    // Fallback to regular copy
    std::fs::copy(src, dest).map_err(|e| {
        DnxError::Io(format!(
            "Failed to copy {} to {}: {}",
            src.display(),
            dest.display(),
            e
        ))
    })?;
    Ok(2)
}

/// Hardlink (or reflink/copy) all files from src directory to dest directory.
/// Returns (hardlinks_count, fallback_copies_count)
///
/// Uses a three-tier import strategy per file: reflink → hardlink → copy.
///
/// Two-pass approach:
/// 1. Sequential pass: walk directory tree, create directories, collect file entries
/// 2. Parallel pass: import files using rayon
fn hardlink_dir(src: &Path, dest: &Path) -> Result<(usize, usize)> {
    // Pass 1: collect entries, create directories
    let mut files: Vec<(PathBuf, PathBuf)> = Vec::new();

    for entry in WalkDir::new(src).into_iter() {
        let entry = entry.map_err(|e| {
            DnxError::Io(format!("Failed to walk directory {}: {}", src.display(), e))
        })?;

        let path = entry.path();
        let relative = path.strip_prefix(src).map_err(|e| {
            DnxError::Io(format!(
                "Failed to get relative path for {}: {}",
                path.display(),
                e
            ))
        })?;

        let dest_path = dest.join(relative);

        if entry.file_type().is_dir() {
            match std::fs::create_dir_all(&dest_path) {
                Ok(()) => {}
                Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}
                Err(e) => {
                    return Err(DnxError::Io(format!(
                        "Failed to create directory {}: {}",
                        dest_path.display(),
                        e
                    )));
                }
            }
        } else if entry.file_type().is_file() {
            files.push((path.to_path_buf(), dest_path));
        }
    }

    // Pass 2: import files in parallel (reflink → hardlink → copy)
    // Skip files that already exist at the destination with matching size
    let hardlinks = AtomicUsize::new(0);
    let copies = AtomicUsize::new(0);

    let result: std::result::Result<Vec<()>, DnxError> = files
        .par_iter()
        .map(|(src_path, dest_path)| {
            // Skip if destination already exists with same file size
            if let Ok(dest_meta) = std::fs::metadata(dest_path) {
                if let Ok(src_meta) = std::fs::metadata(src_path) {
                    if dest_meta.len() == src_meta.len() {
                        hardlinks.fetch_add(1, Ordering::Relaxed);
                        return Ok(());
                    }
                }
            }
            // Remove stale dest file before importing (hardlink fails if dest exists)
            let _ = std::fs::remove_file(dest_path);
            match import_file(src_path, dest_path)? {
                0 | 1 => {
                    hardlinks.fetch_add(1, Ordering::Relaxed);
                }
                _ => {
                    copies.fetch_add(1, Ordering::Relaxed);
                }
            }
            Ok(())
        })
        .collect();

    result?;

    Ok((
        hardlinks.load(Ordering::Relaxed),
        copies.load(Ordering::Relaxed),
    ))
}

/// Create bin scripts for a package
fn create_bin_scripts(bin_dir: &Path, pkg: &ResolvedPackage, pkg_path: &Path) -> Result<()> {
    for (bin_name, bin_path) in &pkg.bin {
        validate_bin_entry(bin_name, bin_path)?;
        // Calculate relative path from bin_dir to actual binary
        let actual_bin = pkg_path.join(bin_path);

        // Get relative path from bin_dir to actual binary
        let bin_dir_abs = bin_dir
            .canonicalize()
            .unwrap_or_else(|_| bin_dir.to_path_buf());
        let actual_bin_abs = actual_bin
            .canonicalize()
            .unwrap_or_else(|_| actual_bin.clone());

        let relative_path = pathdiff::diff_paths(&actual_bin_abs, &bin_dir_abs)
            .unwrap_or_else(|| PathBuf::from("..").join(pkg.name.clone()).join(bin_path));

        #[cfg(windows)]
        {
            // Create .cmd file for Windows
            let cmd_file = bin_dir.join(format!("{}.cmd", bin_name));
            let cmd_content = format!(
                "@IF EXIST \"%~dp0\\node.exe\" (\n  \"%~dp0\\node.exe\" \"%~dp0\\{}\" %*\n) ELSE (\n  node \"%~dp0\\{}\" %*\n)",
                relative_path.to_string_lossy().replace("/", "\\"),
                relative_path.to_string_lossy().replace("/", "\\")
            );
            std::fs::write(&cmd_file, cmd_content).map_err(|e| {
                DnxError::Io(format!(
                    "Failed to write bin script {}: {}",
                    cmd_file.display(),
                    e
                ))
            })?;
        }

        // Create shell script (for Git Bash on Windows, or Unix)
        let sh_file = bin_dir.join(bin_name);
        let sh_content = format!(
            "#!/bin/sh\nbasedir=$(dirname \"$(echo \"$0\" | sed -e 's,\\\\,/,g')\")\nnode \"$basedir/{}\" \"$@\"",
            relative_path.to_string_lossy().replace("\\", "/")
        );
        std::fs::write(&sh_file, sh_content).map_err(|e| {
            DnxError::Io(format!(
                "Failed to write bin script {}: {}",
                sh_file.display(),
                e
            ))
        })?;

        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            // Make shell script executable on Unix
            let mut perms = std::fs::metadata(&sh_file)
                .map_err(|e| DnxError::Io(format!("Failed to get metadata: {}", e)))?
                .permissions();
            perms.set_mode(0o755);
            std::fs::set_permissions(&sh_file, perms)
                .map_err(|e| DnxError::Io(format!("Failed to set permissions: {}", e)))?;
        }
    }

    Ok(())
}

/// Extract bin entries from a package.json file on disk.
/// Used as a fallback when the lockfile doesn't contain bin information.
fn extract_bin_from_package_json(pkg_path: &Path) -> HashMap<String, String> {
    let pj_path = pkg_path.join("package.json");
    let content = match std::fs::read_to_string(&pj_path) {
        Ok(c) => c,
        Err(_) => return HashMap::new(),
    };
    let json: serde_json::Value = match serde_json::from_str(&content) {
        Ok(v) => v,
        Err(_) => return HashMap::new(),
    };
    let pkg_name = json.get("name").and_then(|v| v.as_str()).unwrap_or("");
    let bin_val = json.get("bin");
    match bin_val {
        None => HashMap::new(),
        Some(serde_json::Value::String(s)) => {
            let cmd = if let Some(idx) = pkg_name.rfind('/') {
                &pkg_name[idx + 1..]
            } else {
                pkg_name
            };
            let mut map = HashMap::new();
            if !cmd.is_empty() {
                map.insert(cmd.to_string(), s.clone());
            }
            map
        }
        Some(serde_json::Value::Object(obj)) => {
            let mut map = HashMap::new();
            for (key, val) in obj {
                if let serde_json::Value::String(s) = val {
                    map.insert(key.clone(), s.clone());
                }
            }
            map
        }
        _ => HashMap::new(),
    }
}

/// Parse a dep ref string like "name@version" into (name, version).
fn parse_dep_ref(dep: &str) -> (&str, &str) {
    if let Some(stripped) = dep.strip_prefix('@') {
        if let Some(idx) = stripped.find('@') {
            return (&dep[..idx + 1], &stripped[idx + 1..]);
        }
        return (dep, "");
    }
    if let Some(idx) = dep.find('@') {
        (&dep[..idx], &dep[idx + 1..])
    } else {
        (dep, "")
    }
}

/// Manifest tracking which packages are linked in the virtual store.
/// Used for incremental linking — avoids re-linking unchanged packages.
#[derive(Debug, Default, Serialize, Deserialize)]
struct PackagesManifest {
    /// Map of "name@version" → integrity hash
    packages: HashMap<String, String>,
}

impl PackagesManifest {
    fn new() -> Self {
        Self {
            packages: HashMap::new(),
        }
    }

    fn read(dnx_dir: &Path) -> Self {
        let path = dnx_dir.join("packages.json");
        match std::fs::read_to_string(&path) {
            Ok(content) => serde_json::from_str(&content).unwrap_or_default(),
            Err(_) => Self::default(),
        }
    }

    fn write(&self, dnx_dir: &Path) {
        let path = dnx_dir.join("packages.json");
        if let Ok(content) = serde_json::to_string(self) {
            let _ = std::fs::write(&path, content);
        }
    }
}

/// Attempt to reconstruct a dependency graph from an existing node_modules/.dnx directory.
///
/// Reads `node_modules/.dnx/packages.json` and each package's `package.json` to rebuild
/// the `DependencyGraph` locally, avoiding a full network resolve.
///
/// Returns `None` if the dnx directory or manifest doesn't exist.
pub fn reconstruct_graph_from_node_modules(project_root: &Path) -> Option<DependencyGraph> {
    let dnx_dir = project_root.join("node_modules").join(".dnx");
    let manifest = PackagesManifest::read(&dnx_dir);
    if manifest.packages.is_empty() {
        return None;
    }

    let mut packages = Vec::new();

    for (pkg_key, integrity) in &manifest.packages {
        // Parse "name@version" — handle scoped packages
        let (name, version) = if let Some(stripped) = pkg_key.strip_prefix('@') {
            if let Some(idx) = stripped.find('@') {
                (&pkg_key[..idx + 1], &stripped[idx + 1..])
            } else {
                continue;
            }
        } else if let Some(idx) = pkg_key.find('@') {
            (&pkg_key[..idx], &pkg_key[idx + 1..])
        } else {
            continue;
        };

        let pkg_path = dnx_dir.join(pkg_key).join("node_modules").join(name);
        let pkg_json_path = pkg_path.join("package.json");

        // Read package.json to extract dependencies and bin
        let mut dep_refs = Vec::new();
        let mut peer_dep_refs = Vec::new();
        let mut bin = HashMap::new();
        let mut has_install_script = false;
        let mut tarball_url = String::new();

        if let Ok(content) = std::fs::read_to_string(&pkg_json_path) {
            if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
                // Extract dependencies
                if let Some(deps) = json.get("dependencies").and_then(|d| d.as_object()) {
                    for (dep_name, dep_range) in deps {
                        if let Some(range) = dep_range.as_str() {
                            dep_refs.push(format!("{}@{}", dep_name, range));
                        }
                    }
                }
                // Extract peerDependencies
                if let Some(peers) = json.get("peerDependencies").and_then(|d| d.as_object()) {
                    for (dep_name, dep_range) in peers {
                        if let Some(range) = dep_range.as_str() {
                            peer_dep_refs.push(format!("{}@{}", dep_name, range));
                        }
                    }
                }
                // Extract bin
                if let Some(bin_val) = json.get("bin") {
                    match bin_val {
                        serde_json::Value::String(s) => {
                            let cmd = if let Some(idx) = name.rfind('/') {
                                &name[idx + 1..]
                            } else {
                                name
                            };
                            if !cmd.is_empty() {
                                bin.insert(cmd.to_string(), s.clone());
                            }
                        }
                        serde_json::Value::Object(obj) => {
                            for (k, v) in obj {
                                if let serde_json::Value::String(s) = v {
                                    bin.insert(k.clone(), s.clone());
                                }
                            }
                        }
                        _ => {}
                    }
                }
                // Check for install scripts
                if let Some(scripts) = json.get("scripts").and_then(|s| s.as_object()) {
                    has_install_script = scripts.contains_key("preinstall")
                        || scripts.contains_key("install")
                        || scripts.contains_key("postinstall");
                }
                // Extract resolved tarball URL from _resolved field if present
                if let Some(resolved) = json.get("_resolved").and_then(|v| v.as_str()) {
                    tarball_url = resolved.to_string();
                }
            }
        }

        packages.push(crate::resolver::ResolvedPackage {
            name: name.to_string(),
            version: version.to_string(),
            tarball_url,
            integrity: integrity.clone(),
            dependencies: dep_refs,
            peer_dependencies: peer_dep_refs,
            bin,
            has_install_script,
        });
    }

    if packages.is_empty() {
        return None;
    }

    Some(DependencyGraph { packages })
}

/// Simple path diff implementation to avoid external dependency
mod pathdiff {
    use std::path::{Component, Path, PathBuf};

    pub fn diff_paths<P, B>(path: P, base: B) -> Option<PathBuf>
    where
        P: AsRef<Path>,
        B: AsRef<Path>,
    {
        let path = path.as_ref();
        let base = base.as_ref();

        if path.is_absolute() != base.is_absolute() {
            if path.is_absolute() {
                Some(PathBuf::from(path))
            } else {
                None
            }
        } else {
            let mut ita = path.components();
            let mut itb = base.components();
            let mut comps: Vec<Component> = vec![];

            loop {
                match (ita.next(), itb.next()) {
                    (None, None) => break,
                    (Some(a), None) => {
                        comps.push(a);
                        comps.extend(ita.by_ref());
                        break;
                    }
                    (None, _) => comps.push(Component::ParentDir),
                    (Some(a), Some(b)) if comps.is_empty() && a == b => (),
                    (Some(a), Some(_)) => {
                        comps.push(Component::ParentDir);
                        for _ in itb {
                            comps.push(Component::ParentDir);
                        }
                        comps.push(a);
                        comps.extend(ita.by_ref());
                        break;
                    }
                }
            }
            Some(comps.iter().map(|c| c.as_os_str()).collect())
        }
    }
}