Struct Workspace 

pub struct Workspace<'a, R: CommandRunner, D: DependencyResolver = ManifestWalkResolver> {
    pub root: PathBuf,
    pub config: ResolvedConfig,
    pub graph: D,
    pub tags: OnceCell<TagIndex>,
    pub git: OnceCell<GitAccess<'a>>,
    pub runner: &'a R,
    pub manifest_cache: RefCell<BTreeMap<PathBuf, Arc<dyn Manifest>>>,
    pub identity: IdentityIndex,
}

Fields

root: PathBuf

config: ResolvedConfig

graph: D

tags: OnceCell<TagIndex>

Deferred TagIndex: built at most once, the first time Workspace::tags is called, not eagerly by Workspace::load.

TagIndex::build fetches the repo’s full tag list – native gix, or (unavailable on wasm32) a shelled git tag --list Extism round-trip. Several command paths never consult tags at all (add’s non-interactive path only needs Workspace::root; init only needs package names/root), so building unconditionally in Workspace::load charged every caller for work only some need. All of TagIndex::build’s inputs are already Workspace fields, so a OnceCell needs no extra state – go through Workspace::tags, not this field directly.

git: OnceCell<GitAccess<'a>>

Deferred GitAccess: built at most once, the first time Workspace::git_access is called, mirroring tags above. GitAccess::discover never fails (native gix, falling back to a CommandRunner shell round-trip when unavailable), so simpler than tags – no Result to thread through. Consolidates what were multiple independent GitAccess::discover calls within one command invocation (plan_publish’s head_sha resolution, TagIndex::build via Workspace::tags) into one shared discovery. pub so tests can hand-construct a Workspace with a pre-seeded value, bypassing discovery.

runner: &'a R

manifest_cache: RefCell<BTreeMap<PathBuf, Arc<dyn Manifest>>>

Path-keyed cache of manifest handles opened read-only during this workspace’s lifetime. Populated during graph discovery (ManifestWalkResolver::build) and reused by read-only accessors such as Workspace::base_versions so a given manifest is opened (read + parsed) at most once per command run. Never consulted by the manifest-open-for-write path in apply.rs, which always needs a fresh, exclusively-owned &mut handle.

identity: IdentityIndex

Implementations

impl<'a, R: CommandRunner> Workspace<'a, R, ManifestWalkResolver>

pub fn load<L: ProjectLocator>( root: PathBuf, locator: &L, runner: &'a R, ) -> Result<Self, GraphError>

impl<'a, R: CommandRunner, D: DependencyResolver> Workspace<'a, R, D>

pub fn tags(&self) -> Result<&TagIndex, GraphError>

Returns the workspace’s TagIndex, building it on first access and reusing the cached result afterwards. See the doc comment on the tags field for why this is deferred rather than built eagerly by Workspace::load.

pub fn git_access(&self) -> &GitAccess<'a>

Returns the workspace’s shared GitAccess, discovering it on first access and reusing the cached result afterwards – mirrors Workspace::tags. Every command that needs git (tag resolution, head SHA lookup, commit history walks, …) should go through this rather than calling GitAccess::discover itself, so a single command invocation never pays for more than one discovery (native gix repository-open, or a CommandRunner shell round-trip when gix is unavailable) regardless of how many of those it needs.

pub fn base_versions(&self) -> Result<BTreeMap<PackageId, Version>, GraphError>

pub fn pre_json_key<'b>(&self, id: &'b PackageId) -> Result<&'b str, GraphError>

pub fn initial_versions(&self) -> Result<Vec<(String, Version)>, GraphError>