Move ResolutionResult to core

Author: akhilles

crates/pcb-zen-core/src/lib.rs

@@ -101,6 +101,12 @@ pub trait FileProvider: Send + Sync {
     /// Canonicalize a path (make it absolute)
     fn canonicalize(&self, path: &std::path::Path)
         -> Result<std::path::PathBuf, FileProviderError>;
+
+    /// Global package cache directory (e.g. `~/.pcb/cache`).
+    /// Returns empty path by default (WASM / in-memory providers).
+    fn cache_dir(&self) -> std::path::PathBuf {
+        std::path::PathBuf::new()
+    }
 }
 
 /// Blanket implementation of FileProvider for Arc<T> where T: FileProvider
@@ -134,6 +140,10 @@ impl<T: FileProvider + ?Sized> FileProvider for Arc<T> {
     ) -> Result<std::path::PathBuf, FileProviderError> {
         (**self).canonicalize(path)
     }
+
+    fn cache_dir(&self) -> std::path::PathBuf {
+        (**self).cache_dir()
+    }
 }
 
 #[derive(Debug, Clone, thiserror::Error)]
@@ -281,6 +291,12 @@ impl FileProvider for DefaultFileProvider {
 
         result
     }
+
+    fn cache_dir(&self) -> std::path::PathBuf {
+        dirs::home_dir()
+            .expect("Cannot determine home directory")
+            .join(".pcb/cache")
+    }
 }
 
 /// Information about a package alias including its target and source

crates/pcb-zen-core/src/resolution.rs

@@ -8,7 +8,7 @@
 //! - Native: checks patches, vendor/, then ~/.pcb/cache
 //! - WASM: only checks vendor/ (everything must be pre-vendored)
 
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap, HashMap, HashSet};
 use std::path::{Path, PathBuf};
 
 use semver::Version;
@@ -360,6 +360,92 @@ impl PackagePathResolver for NativePathResolver {
     }
 }
 
+/// Result of dependency resolution.
+///
+/// This is a data-only type defined in core so it can be referenced by
+/// `EvalContext` / `EvalOutput`. Construction happens in `pcb-zen` which
+/// performs the actual resolution.
+#[derive(Debug, Clone)]
+pub struct ResolutionResult {
+    /// Snapshot of workspace info at the time of resolution
+    pub workspace_info: WorkspaceInfo,
+    /// Map from Package Root (Absolute Path) -> Import URL -> Resolved Absolute Path
+    pub package_resolutions: HashMap<PathBuf, BTreeMap<String, PathBuf>>,
+    /// Package dependencies in the build closure: ModuleLine -> Version
+    pub closure: HashMap<ModuleLine, Version>,
+    /// Asset dependencies: (module_path, ref) -> resolved_path
+    pub assets: HashMap<(String, String), PathBuf>,
+    /// Whether the lockfile (pcb.sum) was updated during resolution
+    pub lockfile_changed: bool,
+}
+
+/// Transitive dependency closure for a package
+#[derive(Debug, Clone, Default)]
+pub struct PackageClosure {
+    pub local_packages: HashSet<String>,
+    pub remote_packages: HashSet<(String, String)>,
+    pub assets: HashSet<(String, String)>,
+}
+
+impl ResolutionResult {
+    /// Compute the transitive dependency closure for a package.
+    pub fn package_closure(&self, package_url: &str) -> PackageClosure {
+        let workspace_info = &self.workspace_info;
+        let mut closure = PackageClosure::default();
+        let mut visited: HashSet<String> = HashSet::new();
+        let mut stack: Vec<String> = vec![package_url.to_string()];
+
+        let cache = &workspace_info.cache_dir;
+        let vendor_base = workspace_info.root.join("vendor");
+
+        let get_pkg_root = |module_path: &str, version: &str| -> PathBuf {
+            let vendor_path = vendor_base.join(module_path).join(version);
+            if vendor_path.exists() {
+                vendor_path
+            } else {
+                cache.join(module_path).join(version)
+            }
+        };
+
+        while let Some(url) = stack.pop() {
+            if !visited.insert(url.clone()) {
+                continue;
+            }
+
+            if let Some(pkg) = workspace_info.packages.get(&url) {
+                closure.local_packages.insert(url.clone());
+                for dep_url in pkg.config.dependencies.keys() {
+                    stack.push(dep_url.clone());
+                }
+                for (asset_url, asset_spec) in &pkg.config.assets {
+                    if let Ok(ref_str) = crate::extract_asset_ref_strict(asset_spec) {
+                        closure.assets.insert((asset_url.clone(), ref_str));
+                    }
+                }
+            } else if let Some((line, version)) = self.closure.iter().find(|(l, _)| l.path == url) {
+                let version_str = version.to_string();
+                closure
+                    .remote_packages
+                    .insert((url.clone(), version_str.clone()));
+                let pkg_root = get_pkg_root(&line.path, &version_str);
+                if let Some(deps) = self.package_resolutions.get(&pkg_root) {
+                    for dep_url in deps.keys() {
+                        stack.push(dep_url.clone());
+                    }
+                }
+            }
+        }
+
+        for (asset_path, asset_ref) in self.assets.keys() {
+            closure
+                .assets
+                .insert((asset_path.clone(), asset_ref.clone()));
+        }
+
+        closure
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -432,6 +518,7 @@ mod tests {
 
         let workspace = WorkspaceInfo {
             root: workspace_root.clone(),
+            cache_dir: PathBuf::new(),
             config: None,
             packages,
             lockfile: None,

crates/pcb-zen-core/src/workspace.rs

@@ -78,6 +78,10 @@ pub struct DiscoveryError {
 pub struct WorkspaceInfo {
     /// Workspace root directory
     pub root: PathBuf,
+    /// Global package cache directory (e.g. `~/.pcb/cache`).
+    /// Set by native workspace discovery; empty on WASM.
+    #[serde(skip)]
+    pub cache_dir: PathBuf,
     /// Root pcb.toml config (if present)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub config: Option<PcbToml>,
@@ -488,6 +492,7 @@ pub fn get_workspace_info<F: FileProvider>(
 
     Ok(WorkspaceInfo {
         root: workspace_root,
+        cache_dir: file_provider.cache_dir(),
         config,
         packages,
         lockfile,

crates/pcb-zen/src/cache_index.rs

@@ -2,6 +2,7 @@
 
 use anyhow::{Context, Result};
 use pcb_zen_core::config::Lockfile;
+use pcb_zen_core::FileProvider;
 use r2d2::{Pool, PooledConnection};
 use r2d2_sqlite::SqliteConnectionManager;
 use rusqlite::{params, OptionalExtension};
@@ -318,9 +319,7 @@ fn index_path() -> PathBuf {
 }
 
 pub fn cache_base() -> PathBuf {
-    dirs::home_dir()
-        .expect("Cannot determine home directory")
-        .join(".pcb/cache")
+    pcb_zen_core::DefaultFileProvider::new().cache_dir()
 }
 
 /// Ensure the workspace cache symlink exists.

crates/pcb-zen/src/lib.rs

@@ -20,17 +20,18 @@ use std::sync::Arc;
 
 use pcb_sch::Schematic;
 use pcb_zen_core::config::find_workspace_root;
+use pcb_zen_core::resolution::ResolutionResult;
 use pcb_zen_core::FileProvider;
 use pcb_zen_core::{CoreLoadResolver, DefaultFileProvider, EvalContext, EvalOutput, LoadResolver};
 
 pub use pcb_zen_core::file_extensions;
 pub use pcb_zen_core::{Diagnostic, Diagnostics, WithDiagnostics};
 pub use resolve::{
-    copy_dir_all, ensure_sparse_checkout, resolve_dependencies, vendor_deps, ResolutionResult,
+    copy_dir_all, ensure_sparse_checkout, print_dep_tree, resolve_dependencies, vendor_deps,
     VendorResult,
 };
 pub use starlark::errors::EvalSeverity;
-pub use workspace::{get_workspace_info, MemberPackage, PackageClosure, WorkspaceInfo};
+pub use workspace::{get_workspace_info, MemberPackage, WorkspaceInfo};
 
 pub use tags::get_all_versions_for_repo;