Walkthrough

Adds compatibility-package extensions and config wiring; applies compat extender at install-time; refactors resolve_peers for SCC-aware deterministic final depPath and graph merging; adjusts workspace cache scoping and lockfile dependency-field precedence; normalizes partial <= semver; and adds tests and fixtures.

Changes

All-in-one review checkpoint

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Possibly related PRs

• pnpm/pnpm#12273: Closely related peer parent-context and resolve_peers refactor.
• pnpm/pnpm#12365: Overlapping resolve_peers cycle/finalization work and tests.
• pnpm/pnpm#12128: Related changes to WantedKey cache scoping for project-relative resolutions.

"I'm a rabbit in a resolver tree,
I hop through peers and chase the key,
I stitch a compat DB with care,
I chase cyclic names until they're fair,
Lockfiles hum — deterministic and free!"

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

• X
• Mastodon
• Reddit
• LinkedIn

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

Description

In Walker::walk, resolved_peer_providers_by_alias uses or_insert, making the *first* seen
provider for a peer alias win, which diverges from pnpm’s Object.assign-based merging (last write
wins) and from pacquet’s own overwrite-merge used when bubbling providers from children. This can
select a different provider NodeId to append as a hidden direct dep, changing auto-install-peers
behavior and potentially lockfile parity.

Code

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[R665-666]

+            for (peer_alias, peer_node_id) in output.auto_install_resolved_peers {
+                self.resolved_peer_providers_by_alias.entry(peer_alias).or_insert(peer_node_id);

Evidence

The PR introduces a new aggregation of auto_install_resolved_peers where the top-level merge is
first-write-wins, while pacquet’s child merge and pnpm’s resolvedPeers merge are overwrite-based;
since the aggregated map drives hidden direct-dep appends, a different merge policy can change which
provider is appended.

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[641-667]
pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[999-1015]
pacquet/crates/resolving-deps-resolver/src/resolve_importer.rs[508-535]
installing/deps-resolver/src/resolveDependencies.ts[594-612]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`Walker::walk` aggregates `output.auto_install_resolved_peers` into `resolved_peer_providers_by_alias` via `entry(...).or_insert(...)`, so the first provider encountered for a given peer alias is kept and later providers are dropped. pnpm’s equivalent `resolvedPeers` aggregation uses `Object.assign`, which overwrites earlier values (last write wins), and pacquet already uses overwrite semantics when merging these maps from child outputs.
## Issue Context
This map is consumed by `ResolveImporter::append_resolved_peer_providers` to append hidden direct dependencies used by the auto-install-peers loop.
## Fix Focus Areas
- pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[655-667]
## Suggested change
Replace `entry(...).or_insert(...)` with an overwrite insert (e.g. `self.resolved_peer_providers_by_alias.insert(peer_alias, peer_node_id);`) so duplicate aliases resolve consistently with pnpm-style merging and with the overwrite behavior already used when combining child outputs.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

ordered_child_entries de-duplicates child edges by NodeId, so when multiple aliases map to the
same leaf NodeId only the first alias is walked and inserted into child_dep_paths. This can
silently omit dependency edges from the final DependenciesGraph, leading to missing alias entries
in install/lockfile output.

Code

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[R2550-2564]

+fn ordered_child_entries(
+    children: &BTreeMap<String, NodeId>,
+    parent_refs: &ParentRefs,
+) -> Vec<(String, NodeId)> {
+    let mut out = Vec::with_capacity(children.len());
+    let mut seen = HashSet::new();
+    for repeated in [true, false] {
+        for (alias, node_id) in children {
+            if parent_refs.contains_key(alias) != repeated {
+                continue;
+            }
+            if seen.insert(node_id.clone()) {
+                out.push((alias.clone(), node_id.clone()));
+            }
+        }

Evidence

The helper drops distinct alias edges whenever the same NodeId repeats, but leaf NodeIds are
intentionally reused (derived from pkgIdWithPatchHash, not alias). Since the child-walk loop only
inserts child_dep_paths for aliases returned by ordered_child_entries, any dropped alias is
omitted from the node’s recorded edges and thus from the rebuilt DependenciesGraph.

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[994-1010]
pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[2550-2564]
pacquet/crates/resolving-deps-resolver/src/node_id.rs[15-43]
pacquet/crates/resolving-deps-resolver/src/resolve_dependency_tree.rs[1424-1427]
pacquet/crates/resolving-deps-resolver/src/resolved_tree.rs[184-219]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`ordered_child_entries()` currently filters children using a `seen: HashSet<NodeId>`, which drops later `(alias, node_id)` pairs when the same `NodeId` appears under multiple aliases. Because `resolve_node()` later builds `child_dep_paths` only from the returned list, dropped aliases disappear from the graph.
This is incorrect when a parent legitimately has two aliases pointing at the same leaf node (leaf `NodeId`s are derived from package id and are reused), because both alias edges must remain in the dependency graph.
## Issue Context
- Leaf nodes reuse `NodeId::Leaf(pkg_id)` across occurrences, so different aliases can share the same `NodeId`.
- `DependenciesTreeNode` children are keyed by alias and can contain multiple aliases pointing to the same `NodeId`.
## Fix Focus Areas
- pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[2550-2566]
- pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[994-1010]
## Suggested fix
Option A (simplest, safest):
- Remove the `seen` de-duplication from `ordered_child_entries()` so it returns **all** `(alias, node_id)` pairs in deterministic order.
Option B (keep perf optimization without losing edges):
- Keep `ordered_child_entries()` returning all pairs.
- In the loop that processes `child_entries`, memoize `child_output` per `NodeId` (e.g., `HashMap<NodeId, NodeOutput>`) so each unique `NodeId` is resolved once, but `child_dep_paths.insert(alias, dep_path)` is still performed for every alias.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

cyclic_peer_names() implements Tarjan SCC via a recursive strongconnect() which can overflow the
process stack on sufficiently deep peer-name graphs, crashing peer resolution. This file already
uses an iterative Tarjan for node SCCs, so this recursive path is an outlier on a graph-shaped
input.

Code

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[R1516-1523]

+                if let Some(neighbors) = self.graph.get(name) {
+                    for child in neighbors {
+                        if !self.index_of.contains_key(child) {
+                            self.strongconnect(child);
+                            let name_low = self.low_of[name];
+                            let child_low = self.low_of[child];
+                            self.low_of.insert(name.to_string(), name_low.min(child_low));
+                        } else if self.on_stack.contains(child) {

Evidence

The code shows a direct recursive call in the Tarjan walk for peer names, which can recurse once per
edge on long chains; nearby code documents the need for an iterative Tarjan to avoid deep-recursion
issues.

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[1478-1566]
pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[1568-1572]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`cyclic_peer_names()` uses a recursive Tarjan DFS (`self.strongconnect(child)`), which can stack overflow on large/deep peer-name graphs.

## Issue Context
`peer_sccs()` in the same file explicitly uses an iterative Tarjan to avoid deep recursion; `cyclic_peer_names()` should follow the same robustness approach.

## Fix Focus Areas
- pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[1478-1566]
- pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[1568-1572]

## Implementation notes
- Replace the recursive `PeerNameTarjan::strongconnect` with an explicit work stack (similar to the iterative Tarjan in `peer_sccs`).
- Preserve determinism (the graph is a `BTreeMap<String, BTreeSet<String>>`, so neighbor iteration order is already stable).

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

dep_path_with_allowed_peer_segments() returns None when filtering removes all peer segments
(kept.is_empty()), so final_peer_edge_dep_path() cannot rewrite a peer edge to a peerless
depPath (pkgIdWithPatchHash) unless that peerless variant already exists in variants_by_pkg_id. In
that case the logic falls back to selecting an existing subset variant or returning the original
depPath.

Code

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[R2439-2441]

+    if kept.is_empty() || kept.len() == segments.len() {
+        return None;
+    }

Evidence

The helper explicitly returns None when all segments would be removed, and the caller only
performs trimming when it receives Some(trimmed), otherwise it falls through to existing-variant
selection or returning the original depPath.

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[1806-1875]
pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[2423-2452]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`dep_path_with_allowed_peer_segments()` treats `kept.is_empty()` as "no rewrite" and returns `None`, which prevents `final_peer_edge_dep_path()` from ever producing a peerless depPath via trimming when *all* peer segments are disallowed.

## Issue Context
`final_peer_edge_dep_path()` only attempts a rewrite/synthetic node when `dep_path_with_allowed_peer_segments()` returns `Some(trimmed)`. When it returns `None`, the function can only choose a pre-existing subset variant (including a peerless one) or fall back to `original`.

## Fix Focus Areas
- pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[1806-1875]
- pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs[2423-2452]

## Implementation notes
- Change `dep_path_with_allowed_peer_segments()` so that when `kept.is_empty()` it returns `Some(DepPath::from(raw[..peers_index] + patch_hash_if_any))` (i.e. remove the entire peer suffix), rather than `None`.
- Ensure caller behavior remains correct when the trimmed depPath is peerless:
 - If the peerless variant already exists, return it.
 - Otherwise, allow synthesizing a peerless variant node when needed (consistent with existing synthetic-node handling for partially-trimmed cases).

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

dedupe_peer_dependents derives a package name by slicing resolved_package_id at the last '@',
but resolved_package_id can be a raw non-registry identifier that contains '@' (e.g. git SSH IDs).
This produces bogus names that can make the peer-compatibility check incorrectly skip (or
mis-evaluate) edge rewrites, leaving extra peer variants in the graph/lockfile.

Code

pacquet/crates/resolving-deps-resolver/src/dedupe_peer_dependents.rs[R282-284]

+fn package_name_from_pkg_id(pkg_id: &str) -> String {
+    pkg_id.rfind('@').map_or_else(|| pkg_id.to_string(), |index| pkg_id[..index].to_string())
+}

Evidence

The new compatibility logic adds package_name_from_pkg_id() and uses it to augment the peer-name
sets used for collapse/rewrite decisions. However, the resolver pipeline can produce
resolved_package_id values that are not simple name@version strings (notably git IDs, which can
include git@…), so splitting on the last @ can yield a non-package name and skew the
compatibility predicate.

pacquet/crates/resolving-deps-resolver/src/dedupe_peer_dependents.rs[276-284]
pacquet/crates/resolving-deps-resolver/src/resolve_dependency_tree.rs[2386-2417]
pacquet/crates/resolving-git-resolver/src/git_resolver.rs[114-140]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`package_name_from_pkg_id()` assumes `resolved_package_id` is always in `name@version` form and extracts the name by taking everything before the last `@`. This breaks for non-registry IDs that legitimately contain `@` (notably git SSH IDs like `git@github.com:…`, and potentially other raw IDs).
The extracted value is then used in `collapsed_target_matches_parent()` compatibility checks, which can change whether dep-path variants are rewritten/collapsed.
## Issue Context
`resolved_package_id` is not guaranteed to be `name@version`:
- For git resolutions, `ResolveResult.id` can be a git identifier containing `@` (e.g. `git@…`) and `name_ver` may be `None`.
- `build_pkg_id_with_patch_hash()` can also return the raw id in some cases (no `name_ver` and no manifest name).
So name extraction must not depend on `rfind('@')` over the whole id string.
## Fix Focus Areas
- pacquet/crates/resolving-deps-resolver/src/dedupe_peer_dependents.rs[276-284]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

🐞 Bugs (4) 📘 Rule violations (0) 📎 Requirement gaps (0)

🐞 Bugs (3) 📘 Rule violations (0) 📎 Requirement gaps (0)

🐞 Bugs (1) 📘 Rule violations (0) 📎 Requirement gaps (0)

• Fix transitive peer depPaths to use providers' final peer suffixes, matching pnpm lockfile
  snapshots.
• Add pnpm/Yarn compatibility package extensions to pacquet with an ignoreCompatibilityDb switch.
• Align workspace peer resolution and caching behavior; expand regression coverage across TS and
  Rust.

The following are alternative approaches to this PR:

Recommendation: The PR’s approach (track resolver-stage resolved peer providers, finalize depPaths with full peer depPaths, and vendor a deterministic compat-extension DB behind a config flag) is the best balance for pnpm lockfile parity and reproducibility. The added safeguards (cycle-name handling, deterministic node ordering, and extensive regression tests) reduce the risk inherent in peer/depPath changes; a verbatim upstream port or structural final-depPath redesign would be higher blast-radius.

createReadPackageHook.ts Merge compat DB + user packageExtensions into one effective extender +68/-5

Merge compat DB + user packageExtensions into one effective extender

• Introduces getEffectivePackageExtensions() to merge @yarnpkg/extensions compatibility entries with user-defined packageExtensions and honor ignoreCompatibilityDb. Adds deterministic field-wise merging to handle duplicate selectors in the compat database.

hooks/read-package-hook/src/createReadPackageHook.ts

---

index.ts Export getEffectivePackageExtensions helper +1/-1

Export getEffectivePackageExtensions helper

• Re-exports getEffectivePackageExtensions alongside createReadPackageHook for external use/tests.

hooks/read-package-hook/src/index.ts

---

compat_package_extensions.json Vendor @yarnpkg/extensions compatibility package-extensions database +1602/-0

Vendor @yarnpkg/extensions compatibility package-extensions database

• Adds a bundled JSON database of compatibility package extensions used to patch known-broken manifests during resolution.

pacquet/crates/package-manager/src/compat_package_extensions.json

---

compat_package_extensions.rs Load and merge compat extensions into a reusable PackageExtender +73/-0

Load and merge compat extensions into a reusable PackageExtender

• Implements a OnceLock-cached loader for the JSON DB and merges duplicate selectors deterministically into a PackageExtender.

pacquet/crates/package-manager/src/compat_package_extensions.rs

---

install_with_fresh_lockfile.rs Apply built-in compat extensions and support resolvePeersFromWorkspaceRoot +23/-13

Apply built-in compat extensions and support resolvePeersFromWorkspaceRoot

• Applies the bundled compatibility package extender ahead of user packageExtensions/overrides unless ignore_compatibility_db is set. Computes packageExtensionsChecksum once and threads resolve_peers_from_workspace_root into workspace resolve options.

pacquet/crates/package-manager/src/install_with_fresh_lockfile.rs

---

lib.rs Wire compat_package_extensions module into package-manager crate +1/-0

Wire compat_package_extensions module into package-manager crate

• Adds the compat_package_extensions module to the crate module list so it can be used by install paths.

pacquet/crates/package-manager/src/lib.rs

---

resolve_workspace.rs Support resolvePeersFromWorkspaceRoot option +6/-0

Support resolvePeersFromWorkspaceRoot option

• Adds workspace resolve option resolve_peers_from_workspace_root and threads it into the workspace peer-resolution pass.

pacquet/crates/resolving-deps-resolver/src/resolve_workspace.rs

---

dependencies_graph_to_lockfile.rs Match pnpm dependency field precedence for duplicate aliases +5/-5

Match pnpm dependency field precedence for duplicate aliases

• Adjusts direct-dependency group precedence so optionalDependencies wins over dependencies wins over devDependencies, matching pnpm's field ordering for specifiers/importer sections.

pacquet/crates/package-manager/src/dependencies_graph_to_lockfile.rs

---

dedupe_peer_dependents.rs Prevent collapsing peer variants when parent edges require incompatible suffixes +141/-2

Prevent collapsing peer variants when parent edges require incompatible suffixes

• Enhances dedupe_peer_dependents to only remap child depPaths when the collapsed target’s peer suffix requirements are compatible with the parent edge context, parsing peer names from depPath suffixes.

pacquet/crates/resolving-deps-resolver/src/dedupe_peer_dependents.rs

---

resolve_dependency_tree.rs Scope wanted-resolution cache by project_dir for workspace-semver cases +21/-21

Scope wanted-resolution cache by project_dir for workspace-semver cases

• Expands cache key scoping so workspace mode semver specs (which may resolve to importer-relative link: paths) include project_dir, preventing cross-importer reuse of relative directory resolutions.

pacquet/crates/resolving-deps-resolver/src/resolve_dependency_tree.rs

---

resolve_importer.rs Append resolver-stage peer providers as hidden direct deps for auto-install +40/-2

Append resolver-stage peer providers as hidden direct deps for auto-install

• Captures resolved peer providers from resolve_peers and, when auto-install-peers is enabled, appends eligible providers into the importer's hidden direct dependencies to match pnpm’s resolver-stage resolvedPeers behavior.

pacquet/crates/resolving-deps-resolver/src/resolve_importer.rs

---

resolve_peers.rs Finalize peer depPaths using provider final suffixes + track resolved providers +704/-106

Finalize peer depPaths using provider final suffixes + track resolved providers

• Reworks final depPath computation so peer IDs for transitive edges use providers’ fully-finalized depPaths, avoiding provisional suffix leakage into lockfile snapshots. Tracks resolver-stage resolved peer providers for auto-install-peers and adds deterministic ordering/cycle guards in finalization.

pacquet/crates/resolving-deps-resolver/src/resolve_peers.rs

---

pick_package_from_meta.rs Normalize partial '<=' comparators to pnpm-like upper bounds +53/-1

Normalize partial '<=' comparators to pnpm-like upper bounds

• Normalizes ranges like "<=27" or "<= 27" to an exclusive prerelease upper bound (e.g., "<28.0.0-0") before parsing, matching expected selection behavior for partial comparators.

pacquet/crates/resolving-npm-resolver/src/pick_package_from_meta.rs

---

install.rs Reuse shared packageExtensionsChecksum computation +2/-7

Reuse shared packageExtensionsChecksum computation

• Refactors lockfile drift checking to call the shared compute_package_extensions_checksum helper from install_with_fresh_lockfile.

pacquet/crates/package-manager/src/install.rs

---

createReadPackageHook.ts Add test for merging duplicate compat selectors +10/-1

Add test for merging duplicate compat selectors

• Adds regression coverage ensuring duplicate selectors in the compatibility DB are merged into a single effective extension map.

hooks/read-package-hook/test/createReadPackageHook.ts

---

peerDependencies.ts Add pnpm installer test for pending transitive peer final suffix +19/-0

Add pnpm installer test for pending transitive peer final suffix

• Adds a lockfile snapshot assertion that transitive pending peers use the provider's final peer suffix, not a provisional one.

installing/deps-installer/test/install/peerDependencies.ts

---

resolvePeers.ts Add pnpm resolver test for provider final suffix in transitive pending peer +90/-0

Add pnpm resolver test for provider final suffix in transitive pending peer

• Adds a minimal resolvePeers graph test covering the pending-peer scenario where the provider’s final suffix must be used transitively.

installing/deps-resolver/test/resolvePeers.ts

---

install.rs CLI regression test for final peer suffix in pnpm-lock.yaml +35/-0

CLI regression test for final peer suffix in pnpm-lock.yaml

• Adds an end-to-end pacquet CLI install test asserting the produced lockfile snapshot contains the final peer suffix variant and not the provisional one.

pacquet/crates/cli/tests/install.rs

---

tests.rs Test ignoreCompatibilityDb parsing and application +12/-0

Test ignoreCompatibilityDb parsing and application

• Adds a unit test verifying the YAML key is parsed and correctly sets Config::ignore_compatibility_db.

pacquet/crates/config/src/workspace_yaml/tests.rs

---

tests.rs Test pnpm precedence for duplicated manifest aliases +33/-0

Test pnpm precedence for duplicated manifest aliases

• Adds a regression test ensuring a duplicated alias across groups is recorded in optionalDependencies per pnpm precedence.

pacquet/crates/package-manager/src/dependencies_graph_to_lockfile/tests.rs

---

tests.rs Add lockfile parity tests for final peer suffix and compat DB +157/-0

Add lockfile parity tests for final peer suffix and compat DB

• Adds tests asserting transitive pending peers produce final-suffix snapshots and that the built-in compatibility DB is applied (or skipped via ignore flag) without writing packageExtensionsChecksum.

pacquet/crates/package-manager/src/install/tests.rs

---

tests.rs Update test config struct for ignore_compatibility_db default +1/-0

Update test config struct for ignore_compatibility_db default

• Extends test Config initialization to include ignore_compatibility_db with default false.

pacquet/crates/package-manager/src/install_package_from_registry/tests.rs

---

tests.rs Add regression test for incompatible peer variant retention +44/-0

Add regression test for incompatible peer variant retention

• Adds a scenario where direct deps collapse to a larger variant but a consumer edge retains the smaller incompatible peer variant, ensuring both remain in the graph.

pacquet/crates/resolving-deps-resolver/src/dedupe_peer_dependents/tests.rs

---

tests.rs Test hidden-direct peer provider appending rules +125/-6

Test hidden-direct peer provider appending rules

• Adds tests verifying real peerDependencies providers are appended as hidden direct deps, while meta-only peerDependenciesMeta providers are not.

pacquet/crates/resolving-deps-resolver/src/resolve_importer/tests.rs

---

tests.rs Add peer-resolution regression tests (final suffix, alias filtering) +606/-13

Add peer-resolution regression tests (final suffix, alias filtering)

• Adds tests for transitive pending peer final suffix behavior and ensures non-peer-relevant child aliases do not satisfy peers via real package name heuristics.

pacquet/crates/resolving-deps-resolver/src/resolve_peers/tests.rs

---

tests.rs Add workspace tests for per-importer link caching and root peer resolution +184/-13

Add workspace tests for per-importer link caching and root peer resolution

• Adds tests asserting importer-relative link: resolutions are cached per project_dir and that root workspace direct deps can be used to resolve peers for child importers when enabled.

pacquet/crates/resolving-deps-resolver/src/resolve_workspace/tests.rs

---

tests.rs Add tests for partial '<=' normalization behavior +23/-0

Add tests for partial '<=' normalization behavior

• Adds regression tests ensuring partial "<=27" admits all 27.x versions and that overflow in bound calculation returns None.

pacquet/crates/resolving-npm-resolver/src/pick_package_from_meta/tests.rs

---

peerDependencies.ts Add pnpm E2E test for pending transitive peer final suffix +23/-0

Add pnpm E2E test for pending transitive peer final suffix

• Adds a pnpm test asserting lockfile snapshots contain the final peer suffix form for the transitive pending peer scenario.

pnpm/test/install/peerDependencies.ts

---

package.json Add fixture package final-peer-a +11/-0

Add fixture package final-peer-a

• Introduces an e2e fixture package with dependencies and a peerDependency used to reproduce the pending transitive peer suffix scenario.

pnpr/.fixtures/packages/@pnpm.e2e/final-peer-a/1.0.0/package.json

---

package.json Add fixture package final-peer-b +7/-0

Add fixture package final-peer-b

• Introduces an e2e fixture package declaring a peerDependency on final-peer-a.

pnpr/.fixtures/packages/@pnpm.e2e/final-peer-b/1.0.0/package.json

---

package.json Add fixture package final-peer-c +4/-0

Add fixture package final-peer-c

• Introduces an e2e fixture package acting as the peer provider in the scenario.

pnpr/.fixtures/packages/@pnpm.e2e/final-peer-c/1.0.0/package.json

---

package.json Add fixture package final-peer-x +7/-0

Add fixture package final-peer-x

• Introduces an e2e fixture package that peers on final-peer-b, forming the transitive pending peer chain.

pnpr/.fixtures/packages/@pnpm.e2e/final-peer-x/1.0.0/package.json

---

TEST_PORTING.md Document newly-ported parity tests +6/-0

Document newly-ported parity tests

• Updates the test porting plan to mark the transitive pending peer final-suffix cases as ported and notes added install/CLI coverage.

pacquet/plans/TEST_PORTING.md

---

.typos.toml Whitelist 'ect' token for repo typos checks +1/-0

Whitelist 'ect' token for repo typos checks

• Adds an allowlisted word entry so existing content isn't flagged by typos tooling.

.typos.toml

---

env_overlay.rs Add IGNORE_COMPATIBILITY_DB env overlay field +1/-0

Add IGNORE_COMPATIBILITY_DB env overlay field

• Extends workspace settings env overlay to accept IGNORE_COMPATIBILITY_DB and map it into settings.

pacquet/crates/config/src/env_overlay.rs

---

lib.rs Introduce ignore_compatibility_db config flag +5/-0

Introduce ignore_compatibility_db config flag

• Adds Config::ignore_compatibility_db, defaulting to false, to control whether the built-in compatibility DB is applied.

pacquet/crates/config/src/lib.rs

---

workspace_yaml.rs Parse/apply ignoreCompatibilityDb workspace setting +3/-1

Parse/apply ignoreCompatibilityDb workspace setting

• Adds ignoreCompatibilityDb to workspace YAML settings, includes it in reset/apply plumbing, and threads it through config application.

pacquet/crates/config/src/workspace_yaml.rs

---