Struct PeerContextOptions 

pub struct PeerContextOptions {
    pub dedupe_peer_dependents: bool,
    pub dedupe_peers: bool,
    pub resolve_from_workspace_root: bool,
    pub peers_suffix_max_length: usize,
}

Walk the resolved graph top-down from each importer and compute a peer-dependency context for every package, producing a new graph whose dep_paths carry pnpm-style (peer@ver) suffixes.

The goal is parity with pnpm’s v9 lockfile output: the same name@version can appear multiple times — once per distinct set of peer resolutions — so different subtrees that pin incompatible peers get isolated virtual-store entries and truly different sibling-symlink neighborhoods.

Algorithm per visited package P, reached at some point in a DFS from an importer with ancestor_scope: name -> dep_path_tail:

1. For each peer name declared by P, look it up in ancestor_scope (nearest-ancestor-wins, since the scope is rebuilt per recursion). If missing, fall back to P’s own entry in dependencies — the BFS enqueue above auto-installed it as a transitive, which matches pnpm’s auto-install-peers=true default.
2. Sort the (peer_name, resolution) pairs and serialize as (n1@v1)(n2@v2)… for the suffix.
3. Produce a contextualized dep_path name@version{suffix}. If that key is already in out_packages (or currently on the DFS stack via visiting), short-circuit — we’ve already emitted this variant.
4. Build a new scope for P’s children by merging the ancestor scope with P’s own dependencies (rewritten to point at contextualized children) and the resolved peer map. Recurse.
5. Emit the contextualized LockedPackage.

Cycles: protected by visiting — if a package is re-entered via a dependency cycle, we return the already-computed dep_path without recursing again. The peer context is fixed at first visit; any cycle traversal uses whatever context was live at that first visit.

Nested peer suffixes: pnpm writes (react-dom@18.2.0(react@18.2.0)) when a declared peer has its own resolved peers. A single top-down DFS pass can’t produce that form, because when a parent P records a peer version in its children’s scope, it only knows the canonical tail — the peer’s OWN suffix is computed later when the peer itself gets visited. We solve this by running apply_peer_contexts_once in a fixed-point loop: the second iteration’s input has Pass 1’s contextualized tails in every pkg.dependencies map, so when a descendant looks a peer up in ancestor scope it sees the full nested tail and serializes it as such. Most peer chains converge in 2–3 iterations; we cap at 16 as a safety belt.

Limitations (documented as follow-ups in the README):

• No per-peer range satisfaction — we take whatever the ancestor has, even if it technically doesn’t match P’s declared peer range.

Knobs controlling the peer-context pass. Plumbed from four pnpm-compatible settings (dedupe-peer-dependents, dedupe-peers, resolve-peers-from-workspace-root, peers-suffix-max-length) through the Resolver’s with_* setters.

Fields

dedupe_peer_dependents: bool

When true, run the cross-subtree peer-variant collapse pass after every iteration of the fixed-point loop. Matches pnpm’s default.

dedupe_peers: bool

When true, emit suffixes as (version) instead of (name@version). Affects both the package key, the reference tails stored in dependencies, and the cycle-break form of contains_canonical_back_ref.

resolve_from_workspace_root: bool

When true, unresolved peers can be satisfied by a dep declared at the root importer (".") even if no ancestor scope carries the peer. Runs between own-deps and graph-wide scan in the peer-context visitor — see visit_peer_context in this module for the owning implementation (intentionally crate- private; the public API here is the option flag itself).

peers_suffix_max_length: usize

Byte cap on the peer-ID suffix after which the entire suffix is hashed to _<10-char-sha256-hex>. pnpm’s default is 1000.

Trait Implementations

impl Clone for PeerContextOptions

fn clone(&self) -> PeerContextOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PeerContextOptions

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

Formats the value using the given formatter.

impl Default for PeerContextOptions

fn default() -> Self

Returns the “default value” for a type.

impl Copy for PeerContextOptions