Enum LocalSource 

pub enum LocalSource {
    Directory(PathBuf),
    Tarball(PathBuf),
    Link(PathBuf),
    Portal(PathBuf),
    Exec(PathBuf),
    Git(GitSource),
    RemoteTarball(RemoteTarballSource),
}

Non-registry source for a locked package.

When a package comes from a local path (via file: or link: in package.json) it doesn’t have a tarball URL or integrity hash, so we record the source separately and let the linker materialize it on-the-fly.

Variants

Directory(PathBuf)

file:<dir> — a directory on disk whose contents should be hardlink-copied into the virtual store like a normal package. Path is stored relative to the project root.

Tarball(PathBuf)

file:<tarball> — a .tgz on disk, extracted into the virtual store the same way we extract registry tarballs.

Link(PathBuf)

link:<dir> — a plain symlink into node_modules/<name>, never materialized into the virtual store. Transitive deps are the target’s responsibility.

Portal(PathBuf)

portal:<dir> — a Yarn Berry package portal. The target is a package on disk, but unlike link: its dependencies are still modeled in the lockfile graph.

Exec(PathBuf)

exec:<script> — a Yarn Berry generator script. The script is executed at fetch time and writes the package files into a generated build directory.

Git(GitSource)

git+https://, git+ssh://, github:user/repo, etc. — a remote git repo. Cloned at fetch time and imported like a file: directory. url is the normalized clone URL (what gets passed to git clone). committish is the user-written ref after # (branch, tag, or commit; None means HEAD). resolved is the 40-char commit SHA that git ls-remote pinned the ref to — the lockfile records this so repeat installs reproduce bit-for-bit.

RemoteTarball(RemoteTarballSource)

https://example.com/pkg.tgz — a remote tarball URL. Fetched once at resolve time so the resolver can read the enclosed package.json for version + transitive deps and pin the sha512 integrity. integrity stays empty on freshly-parsed specifiers and is filled in by the resolver after download.

Implementations

impl LocalSource

pub fn path(&self) -> Option<&Path>

The original path (relative to the project root) the user wrote in package.json. None for non-path sources like git.

pub fn kind_str(&self) -> &'static str

The protocol kind ("file" / "link" / "git" / "url").

pub fn is_globally_shareable(&self) -> bool

Whether this source is pinned to immutable, globally reproducible content and can therefore be shared across projects inside aube’s global virtual store, exactly like a registry package.

Git is pinned to a 40-char commit SHA and RemoteTarball to a fetched URL (and, once resolved, an integrity hash), so two projects that depend on the same one resolve to the same files. file: / link: / portal: / exec: all resolve against a path inside the depending project, so they stay per-project and are never promoted into the shared store.

Load-bearing for global-virtual-store correctness: a registry package materialized into the shared store points its dependency siblings at the hashed global path (virtual_store_subdir(dep_path)). If one of those deps were a git/tarball source that only ever landed in the per-project .aube/, the sibling symlink would dangle and Node’s module walk would silently fall back to some unrelated <name> found higher up the tree.

pub fn path_posix(&self) -> String

The path as a POSIX-style string with forward-slash separators. Path::display() and to_string_lossy() honor the host’s separator (backslash on Windows), which would make dep_path hashes and lockfile specifier: strings non-portable: the same file:./some/dir would render as some\dir on Windows and some/dir on Unix, producing two different hashes for the same logical target. Always rendering with / keeps lockfiles cross-platform identical.

pub fn specifier(&self) -> String

Canonical specifier string as pnpm writes it in the packages: and snapshots: keys (post-<name>@ part). For file: / link: this is file:./vendor/foo / link:../sibling. For git, pnpm uses the resolved form <url>#<commit> (no git+ prefix) because the lockfile pins to the exact commit regardless of what the user wrote. Always emits POSIX separators so the resulting lockfile is portable.

pub fn dep_path(&self, name: &str) -> String

Internal FS-safe dep_path used as the key in LockfileGraph.packages and as the .aube/ subdir name.

Distinct paths must map to distinct keys (otherwise the linker would silently mix files between two local packages), and the result must be a single filesystem component — no /, \, :, or ... Ad-hoc character substitution trips over cases like ../vendor vs __/vendor or a.b vs a_b collapsing to the same string, so we hash the raw path bytes and suffix the first 16 hex chars (64 bits — more than enough to avoid collisions inside a single project).

The hash input is the POSIX-form path string so a checked-in lockfile resolves to the same key regardless of which platform ran aube install.

pub fn parse(spec: &str, project_root: &Path) -> Option<Self>

Classify a user-written file: / link: specifier against the project root. Returns None if spec isn’t a local specifier. Resolves the target path relative to project_root; a file: target that resolves to a .tgz / .tar.gz on disk is treated as a tarball, anything else as a directory.

pub fn looks_like_remote_tarball_url(spec: &str) -> bool

Whether a specifier looks like a direct HTTP(S) URL that should be fetched as a tarball. Per npm semantics, any http:// or https:// URL in a dependency value is a tarball URL — services like pkg.pr.new, GitHub codeload, and private registries with auth-token query strings serve tarballs from URLs that don’t carry a .tgz extension. Git URLs must already have been ruled out by the caller (see parse_git_spec) so a .git-suffixed URL doesn’t get misclassified here.

pub fn path_looks_like_tarball(path: &Path) -> bool

Trait Implementations

impl Clone for LocalSource

fn clone(&self) -> LocalSource

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LocalSource

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for LocalSource

impl PartialEq for LocalSource

fn eq(&self, other: &LocalSource) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for LocalSource