fix: don't silently drop locked optional deps on resolution failure (#12855)

When re-resolution of an optional dependency fails (for example, a
registry mirror whose packument has not synced the pinned version yet),
the resolver silently skipped the dependency. The parent's snapshot was
then rewritten without the edge and the pruner erased the locked
entries, so identical inputs produced different lockfiles depending on
which machine ran the install, and a frozen install on another host had
no entry to link for the affected package.

Rethrow the resolution error instead of skipping when the wanted
lockfile already holds an entry that satisfies the wanted range. An
optional dependency that never resolved keeps the skip-on-failure
behavior.

pacquet previously failed loudly on every optional-dependency
resolution failure. It now skips never-locked optional deps like pnpm,
emitting the same skipped-optional-dependency log (with the parents
chain and the same top-level reporter output), and keeps the loud
failure — with the same hint — when the lockfile holds a satisfying
entry, so the two stacks agree on both cases.

Closes #12853

---------

Co-authored-by: Zoltan Kochan <zoltankochan@gmail.com>

Author: davidbarratt

.changeset/optional-locked-resolution-failure.md

@@ -0,0 +1,6 @@
+---
+"@pnpm/installing.deps-resolver": patch
+"pnpm": patch
+---
+
+Fail instead of silently removing an optional dependency's locked entries from `pnpm-lock.yaml` when the registry cannot resolve it. Previously, when registry metadata lacked a version that the lockfile already pinned (for example, a mirror that had not synced a recent release yet), `pnpm install` and `pnpm dedupe` silently dropped the optional dependency's entries — emptying maps such as the platform binaries of `@napi-rs/canvas` — so the lockfile differed between machines and frozen installs on other hosts had nothing to link [#12853](https://github.com/pnpm/pnpm/issues/12853).

pacquet/crates/default-reporter/src/state.rs

@@ -14,7 +14,8 @@ use pacquet_reporter::{
     AddedRoot, ContextLog, DependencyType, ExecutionTimeLog, FetchingProgressMessage, HookLog,
     IgnoredScriptsLog, InstallingConfigDepsLog, InstallingConfigDepsStatus, LifecycleMessage,
     LifecycleStdio, LockfileVerificationMessage, LogEvent, LogLevel, PackageImportMethod,
-    PackageManifestMessage, ProgressMessage, RemovedRoot, RequestRetryLog, Stage, StatsMessage,
+    PackageManifestMessage, ProgressMessage, RemovedRoot, RequestRetryLog,
+    SkippedOptionalDependencyLog, SkippedOptionalPackage, Stage, StatsMessage,
 };
 use serde_json::Value;
 
@@ -323,11 +324,7 @@ impl ReporterState {
             LogEvent::Summary(_) => self.on_summary(),
             LogEvent::Lifecycle(log) => self.on_lifecycle(&log.message),
             LogEvent::IgnoredScripts(log) => self.on_ignored_scripts(log),
-            // Upstream's `reportSkippedOptionalDependencies` only prints top-level
-            // resolution failures (its filter needs a `parents: []`); the emits
-            // pacquet produces carry no `parents`, so upstream drops them from the
-            // console. Consume without rendering to match.
-            LogEvent::SkippedOptionalDependency(_) => {}
+            LogEvent::SkippedOptionalDependency(log) => self.on_skipped_optional(log),
             LogEvent::InstallingConfigDeps(log) => self.on_config_deps(log),
             LogEvent::LockfileVerification(log) => self.on_lockfile_verification(&log.message),
             LogEvent::RequestRetry(log) => self.on_request_retry(log),
@@ -1029,6 +1026,30 @@ impl ReporterState {
         self.exec_slot = slot;
     }
 
+    /// Mirrors pnpm's `reportSkippedOptionalDependencies`: only a skip
+    /// whose `parents` chain is present and empty (a direct optional
+    /// dependency of the current project) renders; transitive and
+    /// parent-less skips stay debug-only.
+    fn on_skipped_optional(&mut self, log: &SkippedOptionalDependencyLog) {
+        if log.prefix != self.cwd || !log.parents.as_ref().is_some_and(Vec::is_empty) {
+            return;
+        }
+        let pkg = match &log.package {
+            SkippedOptionalPackage::Installed { id, .. } => id.clone(),
+            SkippedOptionalPackage::ResolutionFailure {
+                name: Some(name),
+                version: Some(version),
+                ..
+            } => format!("{name}@{version}"),
+            SkippedOptionalPackage::ResolutionFailure { bare_specifier, .. } => {
+                bare_specifier.clone()
+            }
+        };
+        self.push_block(format!(
+            "info: {pkg} is an optional dependency and failed compatibility check. Excluding it from installation.",
+        ));
+    }
+
     /// Renders a `pnpm:hook` event as `hook: message`, matching pnpm's
     /// `reportHooks.ts` format. When the hook's `prefix` differs from
     /// `self.cwd` the message is zoomed out with the prefix.

pacquet/crates/default-reporter/tests/render.rs

@@ -13,7 +13,8 @@ use pacquet_reporter::{
     LifecycleMessage, LifecycleStdio, LogEvent, LogLevel, PackageImportMethod,
     PackageImportMethodLog, PackageManifestLog, PackageManifestMessage, PnpmLog, ProgressLog,
     ProgressMessage, RootLog, RootMessage, SkippedOptionalDependencyLog, SkippedOptionalPackage,
-    SkippedOptionalReason, Stage, StageLog, StatsLog, StatsMessage, SummaryLog,
+    SkippedOptionalParent, SkippedOptionalReason, Stage, StageLog, StatsLog, StatsMessage,
+    SummaryLog,
 };
 
 const CWD: &str = "/repo";
@@ -421,8 +422,8 @@ fn warnings_collapse_after_five() {
     assert_eq!(lines[5], "[WARN] 1 other warnings");
 }
 
-/// Upstream keeps the console silent for the skipped-optional emits pacquet
-/// produces (they carry no `parents`), so this channel must render nothing.
+/// Upstream keeps the console silent for skipped-optional emits without a
+/// `parents` chain (build/platform skips), so those must render nothing.
 #[test]
 fn skipped_optional_dependency_renders_nothing() {
     let mut reporter = state(false);
@@ -435,6 +436,7 @@ fn skipped_optional_dependency_renders_nothing() {
                 name: name.to_string(),
                 version: version.to_string(),
             },
+            parents: None,
             prefix: CWD.to_string(),
             reason,
         })
@@ -454,6 +456,48 @@ fn skipped_optional_dependency_renders_nothing() {
     assert!(frame.is_empty(), "skipped-optional events must not render, got: {frame:?}");
 }
 
+/// A resolution-failure skip on a direct optional dependency
+/// (`parents: []`, prefix == cwd) renders the same info line as
+/// upstream's `reportSkippedOptionalDependencies`; a transitive skip
+/// (non-empty `parents`) stays silent.
+#[test]
+fn skipped_optional_resolution_failure_renders_only_top_level() {
+    let skipped = |parents: Vec<SkippedOptionalParent>, prefix: &str| {
+        LogEvent::SkippedOptionalDependency(SkippedOptionalDependencyLog {
+            level: LogLevel::Debug,
+            details: Some("No matching version found for broken@^1.0.0".to_string()),
+            package: SkippedOptionalPackage::ResolutionFailure {
+                name: Some("broken".to_string()),
+                version: Some("^1.0.0".to_string()),
+                bare_specifier: "^1.0.0".to_string(),
+            },
+            parents: Some(parents),
+            prefix: prefix.to_string(),
+            reason: SkippedOptionalReason::ResolutionFailure,
+        })
+    };
+
+    let mut reporter = state(false);
+    let frame = render(&mut reporter, vec![skipped(Vec::new(), CWD)]);
+    assert_eq!(
+        frame,
+        "info: broken@^1.0.0 is an optional dependency and failed compatibility check. Excluding it from installation.",
+    );
+
+    let mut reporter = state(false);
+    let parent = SkippedOptionalParent {
+        id: "parent@1.0.0".to_string(),
+        name: "parent".to_string(),
+        version: "1.0.0".to_string(),
+    };
+    let frame = render(&mut reporter, vec![skipped(vec![parent], CWD)]);
+    assert!(frame.is_empty(), "transitive skips must not render, got: {frame:?}");
+
+    let mut reporter = state(false);
+    let frame = render(&mut reporter, vec![skipped(Vec::new(), "/somewhere/else")]);
+    assert!(frame.is_empty(), "other prefixes must not render, got: {frame:?}");
+}
+
 #[test]
 fn append_only_emits_lines_not_frames() {
     let mut reporter = ReporterState::new(CWD.to_string(), 80, Colors { enabled: false }, true);

pacquet/crates/env-installer/src/install_config_deps.rs

@@ -319,6 +319,7 @@ fn is_compatible<Reporter: self::Reporter>(
                     name: subdep.name.clone(),
                     version: subdep.version.clone(),
                 },
+                parents: None,
                 prefix: opts.root_dir.to_string_lossy().into_owned(),
                 reason: match error.skip_reason() {
                     pacquet_package_is_installable::SkipReason::UnsupportedEngine => {

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

@@ -945,6 +945,7 @@ fn build_one_snapshot<Reporter: self::Reporter>(
                                             name,
                                             version,
                                         },
+                                        parents: None,
                                         prefix: lockfile_dir.to_string_lossy().into_owned(),
                                         reason: SkippedOptionalReason::BuildFailure,
                                     },
@@ -995,6 +996,7 @@ fn build_one_snapshot<Reporter: self::Reporter>(
                     name,
                     version,
                 },
+                parents: None,
                 prefix: lockfile_dir.to_string_lossy().into_owned(),
                 reason: SkippedOptionalReason::BuildFailure,
             }));
@@ -1072,6 +1074,7 @@ fn build_one_snapshot<Reporter: self::Reporter>(
                                 name,
                                 version,
                             },
+                            parents: None,
                             prefix: lockfile_dir.to_string_lossy().into_owned(),
                             reason: SkippedOptionalReason::BuildFailure,
                         },

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

@@ -21,7 +21,10 @@ use pacquet_hooks::finder;
 use pacquet_lockfile::{Lockfile, LockfileResolution, SaveLockfileError};
 use pacquet_network::{AuthHeaders, ThrottledClient};
 use pacquet_package_manifest::{DependencyGroup, PackageManifest};
-use pacquet_reporter::{HookLog, LogEvent, LogLevel, Reporter, Stage, StageLog};
+use pacquet_reporter::{
+    HookLog, LogEvent, LogLevel, Reporter, SkippedOptionalDependencyLog, SkippedOptionalPackage,
+    SkippedOptionalParent, SkippedOptionalReason, Stage, StageLog,
+};
 use pacquet_resolving_default_resolver::DefaultResolver;
 use pacquet_resolving_deps_resolver::{
     ManifestHook, ResolveDependencyTreeError, ResolveImporterError, ResolveImporterOptions,
@@ -1098,6 +1101,7 @@ impl<DependencyGroupList> InstallWithFreshLockfile<'_, DependencyGroupList> {
             manifest_hook: manifest_hook.clone(),
             pnpmfile_hook,
             read_package_log,
+            skipped_optional_log: Some(skipped_optional_log_fn::<Reporter>()),
             pick_lowest_direct,
             time_based,
             // Hand the resolver the prior lockfile so it can reuse
@@ -2074,6 +2078,38 @@ fn hook_log_fn<Reporter: self::Reporter>(
     })
 }
 
+/// Build the resolver's skipped-optional-dependency sink: each
+/// notification emits a `pnpm:skipped-optional-dependency` debug event
+/// with `reason=resolution_failure` through the install's reporter,
+/// matching pnpm's `skippedOptionalDependencyLogger.debug` payload.
+fn skipped_optional_log_fn<Reporter: self::Reporter>()
+-> pacquet_resolving_deps_resolver::SkippedOptionalLogFn {
+    Arc::new(|skipped: pacquet_resolving_deps_resolver::SkippedOptionalDependency| {
+        Reporter::emit(&LogEvent::SkippedOptionalDependency(SkippedOptionalDependencyLog {
+            level: LogLevel::Debug,
+            details: Some(skipped.details),
+            package: SkippedOptionalPackage::ResolutionFailure {
+                name: skipped.name,
+                version: skipped.version,
+                bare_specifier: skipped.bare_specifier,
+            },
+            parents: Some(
+                skipped
+                    .parents
+                    .into_iter()
+                    .map(|parent| SkippedOptionalParent {
+                        id: parent.id,
+                        name: parent.name,
+                        version: parent.version,
+                    })
+                    .collect(),
+            ),
+            prefix: skipped.prefix,
+            reason: SkippedOptionalReason::ResolutionFailure,
+        }));
+    })
+}
+
 /// Build one side of the `preResolution` hook's `logger`: each
 /// `logger.info(...)` / `logger.warn(...)` call emits a `pnpm:hook` event at
 /// the given level. `from` is the literal `"pnpmfile"` — pnpm's

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

@@ -650,6 +650,7 @@ fn emit_skipped<Reporter: self::Reporter>(
         level: LogLevel::Debug,
         details: Some(details),
         package: SkippedOptionalPackage::Installed { id: pkg_id.to_string(), name, version },
+        parents: None,
         prefix: prefix.to_string(),
         reason: wire_reason,
     }));

pacquet/crates/reporter/src/lib.rs

@@ -570,17 +570,34 @@ pub struct IgnoredScriptsLog {
 /// real safety, so it's left to convention until a site actually
 /// pairs the wrong shapes.
 ///
-/// `parents` is a TODO and is omitted here.
+/// `parents` co-varies with `reason` the same way `package` does:
+/// only the resolver-side `resolution_failure` emit carries it
+/// (empty for a direct optional dependency of the importer); every
+/// other emit site omits it, matching pnpm's payloads.
 #[derive(Debug, Clone, Serialize)]
 pub struct SkippedOptionalDependencyLog {
     pub level: LogLevel,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub details: Option<String>,
     pub package: SkippedOptionalPackage,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parents: Option<Vec<SkippedOptionalParent>>,
     pub prefix: String,
     pub reason: SkippedOptionalReason,
 }
 
+/// One ancestor on a `resolution_failure` skip's `parents` chain: a
+/// resolved package between the importer and the failing optional
+/// edge. The default reporter renders only skips whose chain is empty
+/// (a direct optional dependency), matching pnpm's
+/// `reportSkippedOptionalDependencies`.
+#[derive(Debug, Clone, Serialize)]
+pub struct SkippedOptionalParent {
+    pub id: String,
+    pub name: String,
+    pub version: String,
+}
+
 /// Package identifier carried on a [`SkippedOptionalDependencyLog`].
 /// Two shapes, depending on `reason`:
 ///
@@ -591,9 +608,8 @@ pub struct SkippedOptionalDependencyLog {
 ///   `build_modules.rs`.
 /// - [`SkippedOptionalPackage::ResolutionFailure`] —
 ///   `{ name?, version?, bareSpecifier }` for `resolution_failure`.
-///   Defined for the resolver-side emit. Pacquet has no resolver yet
-///   so this variant is wire-shape-only in slice 4 — wired so a
-///   future resolver port can land without re-touching this type.
+///   Emitted by the deps resolver's skipped-optional sink when an
+///   optional dependency's resolution failure drops the edge.
 ///
 /// `#[serde(untagged)]` so each variant serializes as its own object
 /// shape — a union of two `package: { ... }` types.
@@ -604,8 +620,10 @@ pub enum SkippedOptionalPackage {
     /// emit (installability + build-failure).
     Installed { id: String, name: String, version: String },
     /// `{ name?, version?, bareSpecifier }` shape used by the
-    /// resolver-side `resolution_failure` emit. `name` and `version`
-    /// are optional and stay `None` when the resolver fails before it
+    /// resolver-side `resolution_failure` emit (the deps resolver's
+    /// skipped-optional sink wired in
+    /// `install_with_fresh_lockfile.rs`). `name` and `version` are
+    /// optional and stay `None` when the resolver fails before it
     /// could resolve those fields.
     ResolutionFailure {
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -617,10 +635,9 @@ pub enum SkippedOptionalPackage {
     },
 }
 
-/// Discriminator on a [`SkippedOptionalDependencyLog`]. Only
-/// `BuildFailure` lands at pacquet's current emit sites; the others
-/// are kept in the enum for forward compatibility so callers don't
-/// have to widen the type when more reasons are wired up.
+/// Discriminator on a [`SkippedOptionalDependencyLog`]. See
+/// [`SkippedOptionalPackage`] for which emit site pairs with which
+/// reason.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum SkippedOptionalReason {

pacquet/crates/reporter/src/tests.rs

@@ -11,8 +11,8 @@ use crate::{
     LockfileVerificationMessage, LogEvent, LogLevel, PackageImportMethod, PackageImportMethodLog,
     PackageManifestLog, PackageManifestMessage, PnpmLog, ProgressLog, ProgressMessage, RemovedRoot,
     Reporter, RequestRetryError, RequestRetryLog, RootLog, RootMessage, SilentReporter,
-    SkippedOptionalDependencyLog, SkippedOptionalPackage, SkippedOptionalReason, Stage, StageLog,
-    StatsLog, StatsMessage, SummaryLog,
+    SkippedOptionalDependencyLog, SkippedOptionalPackage, SkippedOptionalParent,
+    SkippedOptionalReason, Stage, StageLog, StatsLog, StatsMessage, SummaryLog,
 };
 
 /// Context log serializes with the camelCase field names
@@ -675,6 +675,7 @@ fn skipped_optional_dependency_event_matches_pnpm_wire_shape() {
             name: "foo".to_string(),
             version: "1.0.0".to_string(),
         },
+        parents: None,
         prefix: "/projects/x".to_string(),
         reason: SkippedOptionalReason::BuildFailure,
     });
@@ -693,6 +694,7 @@ fn skipped_optional_dependency_event_matches_pnpm_wire_shape() {
     assert_eq!(json["package"]["id"], "/foo/1.0.0");
     assert_eq!(json["package"]["name"], "foo");
     assert_eq!(json["package"]["version"], "1.0.0");
+    assert!(json.get("parents").is_none(), "non-resolver emits carry no parents, got {json:?}");
 }
 
 /// `details` is optional upstream and must be omitted from the wire
@@ -707,6 +709,7 @@ fn skipped_optional_omits_absent_details() {
             name: "bar".to_string(),
             version: "2.0.0".to_string(),
         },
+        parents: None,
         prefix: "/projects/y".to_string(),
         reason: SkippedOptionalReason::BuildFailure,
     });
@@ -755,6 +758,11 @@ fn skipped_optional_resolution_failure_event_matches_pnpm_wire_shape() {
             version: Some("1.2.3".to_string()),
             bare_specifier: "^1.2.0".to_string(),
         },
+        parents: Some(vec![SkippedOptionalParent {
+            id: "parent@2.0.0".to_string(),
+            name: "parent".to_string(),
+            version: "2.0.0".to_string(),
+        }]),
         prefix: "/projects/x".to_string(),
         reason: SkippedOptionalReason::ResolutionFailure,
     });
@@ -771,6 +779,10 @@ fn skipped_optional_resolution_failure_event_matches_pnpm_wire_shape() {
     assert_eq!(json["package"]["name"], "foo");
     assert_eq!(json["package"]["version"], "1.2.3");
     assert_eq!(json["package"]["bareSpecifier"], "^1.2.0");
+    assert_eq!(
+        json["parents"],
+        serde_json::json!([{ "id": "parent@2.0.0", "name": "parent", "version": "2.0.0" }]),
+    );
 }
 
 /// `name` and `version` are upstream-optional on the
@@ -786,6 +798,7 @@ fn skipped_optional_resolution_failure_omits_absent_name_and_version() {
             version: None,
             bare_specifier: "git+ssh://broken-url".to_string(),
         },
+        parents: Some(Vec::new()),
         prefix: "/projects/y".to_string(),
         reason: SkippedOptionalReason::ResolutionFailure,
     });
@@ -799,6 +812,7 @@ fn skipped_optional_resolution_failure_omits_absent_name_and_version() {
     assert!(json["package"].get("name").is_none(), "name omitted when absent, got {json:?}");
     assert!(json["package"].get("version").is_none(), "version omitted when absent, got {json:?}");
     assert_eq!(json["package"]["bareSpecifier"], "git+ssh://broken-url");
+    assert_eq!(json["parents"], serde_json::json!([]), "an empty chain serializes as []");
 }
 
 /// All four reason variants serialize as the `snake_case` strings

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

@@ -84,7 +84,8 @@ pub use hoist_peers::{
 pub use node_id::NodeId;
 pub use pacquet_deps_path::DepPath;
 pub use resolve_dependency_tree::{
-    ManifestHook, ResolveDependencyTreeError, ResolveDependencyTreeOptions, TreeCtx,
+    ManifestHook, ResolveDependencyTreeError, ResolveDependencyTreeOptions,
+    SkippedOptionalDependency, SkippedOptionalDependencyParent, SkippedOptionalLogFn, TreeCtx,
     UpdateReuseScope, WorkspaceTreeCtx, extend_tree, resolve_dependency_tree,
 };
 pub use resolve_importer::{