@@ -928,10 +928,22 @@ pub(crate) async fn revert_bun_opts(
         }
     }
 
+    // An empty registry field means "the default registry", which a
+    // committed bunfig.toml or .npmrc can rebind; with either naming a
+    // registry, an empty field proves nothing about where an upgrade
+    // installs from (#1155).
+    let default_registry_pinned = !project_configures_a_registry(project_root).await;
     let mut dirty = false;
     if let Some(lines) = lines.as_mut() {
         for rec in entry.wiring.iter().rev().filter(|r| r.file == BUN_LOCK) {
-            revert_one_record(lines, rec, &entry.uuid, &mut dirty, &mut outcome.warnings);
+            revert_one_record(
+                lines,
+                rec,
+                &entry.uuid,
+                default_registry_pinned,
+                &mut dirty,
+                &mut outcome.warnings,
+            );
         }
         if dirty {
             if let Err(e) = atomic_write_bytes_preserving_mode(
@@ -986,6 +998,7 @@ fn revert_one_record(
     lines: &mut [String],
     rec: &WiringRecord,
     entry_uuid: &str,
+    default_registry_pinned: bool,
     dirty: &mut bool,
     warnings: &mut Vec<VendorWarning>,
 ) {
@@ -1043,7 +1056,7 @@ fn revert_one_record(
             // exactly as after `bun remove`. Nothing to restore; the caller
             // keeps the artifact only while the lock still resolves through
             // it. A same-version re-resolution stays drift.
-            if let Some(live_version) = version_moved_off(rec, &parsed) {
+            if let Some(live_version) = version_moved_off(rec, &parsed, default_registry_pinned) {
                 warnings.push(VendorWarning::new(
                     super::LOCK_ENTRY_REMOVED_CODE,
                     format!(
@@ -1104,16 +1117,36 @@ fn registry_name_version(entry: &BunEntry) -> Option<(String, String)> {
 /// keeps the caller's drift verdict: an `original: None` record, a URL or
 /// `file:` spec, another package or another registry is not a plain upgrade
 /// and must keep the artifact and leave `vendor --check` red.
-fn version_moved_off(rec: &WiringRecord, live: &BunEntry) -> Option<String> {
+fn version_moved_off(
+    rec: &WiringRecord,
+    live: &BunEntry,
+    default_registry_pinned: bool,
+) -> Option<String> {
     let (live_name, live_version) = registry_name_version(live)?;
     let original = parse_entry_line(rec.original.as_ref().and_then(Value::as_str)?).ok()?;
     let (original_name, original_version) = registry_name_version(&original)?;
-    let same_registry = matches!((live.elems.get(1), original.elems.get(1)),
-        (Some(l), Some(o)) if decode_json_string(l).is_some() && decode_json_string(l) == decode_json_string(o));
+    let live_registry = decode_json_string(live.elems.get(1)?)?;
+    let same_registry = Some(&live_registry) == decode_json_string(original.elems.get(1)?).as_ref()
+        && (!live_registry.is_empty() || default_registry_pinned);
     (same_registry && live_name == original_name && live_version != original_version)
         .then_some(live_version)
 }
 
+/// True when the project's own `bunfig.toml` or `.npmrc` mentions a
+/// registry at all (or can't be read), so Bun's default registry may not
+/// be npmjs. Deliberately coarse: any doubt keeps the drift verdict.
+async fn project_configures_a_registry(project_root: &Path) -> bool {
+    for name in ["bunfig.toml", ".npmrc"] {
+        match read_regular_to_string(&project_root.join(name)).await {
+            Ok(text) if text.to_ascii_lowercase().contains("registry") => return true,
+            Ok(_) => {}
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
+            Err(_) => return true,
+        }
+    }
+    false
+}
+
 // ───────────────────────── vendor-specific classification ─────────────────
 // The conservative line grammar (`BunEntry`, `parse_*`, `scan_*`, …) lives in
 // `crate::vendor::bun_lock_text`; this module keeps only the vendor tuple
@@ -3256,6 +3289,45 @@ mod tests {
         }
     }
 
+    /// #1155 provenance guard: an empty registry field means "the default
+    /// registry", and a committed bunfig.toml or .npmrc can rebind that.
+    /// With either naming a registry, a version change from `""` is not
+    /// proven to come from the pre-vendor registry, so it stays drift.
+    #[tokio::test]
+    async fn revert_keeps_default_registry_upgrade_as_drift_when_the_registry_is_configured() {
+        for (file, text) in [
+            (
+                "bunfig.toml",
+                "[install]\nregistry = \"https://evil.example.com/\"\n",
+            ),
+            (".npmrc", "registry=https://evil.example.com/\n"),
+        ] {
+            let fx = fixture_with(BN3_BEFORE_LOCK, "node_modules/left-pad").await;
+            let (_, entry, _) = expect_done(fx.vendor(false).await);
+            let entry = entry.unwrap();
+            let upgraded_line =
+                "    \"left-pad\": [\"left-pad@1.3.1\", \"\", {}, \"sha512-other==\"],";
+            let live = fx.read_lock().await;
+            let new_line = entry.wiring[0]
+                .new
+                .as_ref()
+                .and_then(Value::as_str)
+                .unwrap();
+            tokio::fs::write(
+                fx.root().join(BUN_LOCK),
+                live.replace(new_line, upgraded_line),
+            )
+            .await
+            .unwrap();
+            tokio::fs::write(fx.root().join(file), text).await.unwrap();
+
+            let outcome = revert_bun(&entry, fx.root(), false).await;
+            assert!(outcome.success, "{file}: {:?}", outcome.error);
+            assert!(outcome.drift_skipped(), "{file}: {:?}", outcome.warnings);
+            assert!(outcome.kept_artifact, "{file}: {:?}", outcome.warnings);
+        }
+    }
+
     #[tokio::test]
     async fn revert_leaves_drifted_entries_alone_with_warning() {
         let fx = fixture_with(BN3_BEFORE_LOCK, "node_modules/left-pad").await;
 
@@ -777,7 +777,26 @@ pub async fn revert_npm_opts(
             }
         };
 
-        let non_registry = npm_non_registry_entries(&lock, &overrides);
+        let mut non_registry = npm_non_registry_entries(&lock, &overrides);
+        // An override can also swap a registry edge for a git / URL /
+        // `file:` spec, which that set does not report. Any override that
+        // names the vendored package keeps every record off the upgrade
+        // path; the revert then drift-keeps as before #1155.
+        let overridden = super::npm_common::parse_npm_purl(&entry.base_purl)
+            .is_none_or(|(name, _)| overrides.mentions(&name));
+        if overridden {
+            for rec in entry.wiring.iter().filter(|r| r.file == lock_name) {
+                if let Some(key) = rec.key.as_deref() {
+                    let key = match rec.kind.as_str() {
+                        KIND_LOCK_LEGACY_ENTRY => legacy_pointer_packages_key(key),
+                        _ => Some(key.to_string()),
+                    };
+                    if let Some(key) = key {
+                        non_registry.insert(key, "an override names the package".to_string());
+                    }
+                }
+            }
+        }
         let mut changed = false;
         // Reverse application order, like every backend's revert.
         for rec in entry.wiring.iter().rev().filter(|r| r.file == lock_name) {
@@ -3620,6 +3639,51 @@ mod tests {
         }
     }
 
+    /// #1155 provenance guard: an override can swap a registry edge for a
+    /// git / URL / `file:` spec that npm ci installs instead of the lock's
+    /// `resolved`. While any override names the vendored package, a version
+    /// change is not trusted as a registry upgrade and stays drift.
+    #[tokio::test]
+    async fn revert_keeps_version_change_as_drift_while_an_override_names_the_package() {
+        for overrides in [
+            json!({ "left-pad": "file:../left-pad" }),
+            json!({ "foo": { "left-pad": "github:evil/left-pad" } }),
+            json!({ "left-pad@1.3.0": "https://example.com/left-pad.tgz" }),
+        ] {
+            let fx = fixture().await;
+            let (_, entry, _) = expect_done(fx.vendor(false).await);
+            let entry = entry.unwrap();
+            let manifest = json!({ "name": "fixture", "version": "1.0.0", "overrides": overrides });
+            tokio::fs::write(
+                fx.root().join("package.json"),
+                serialize_json(&manifest, "  ").unwrap(),
+            )
+            .await
+            .unwrap();
+
+            let upgraded = json!({
+                "version": "1.3.1",
+                "resolved": "https://registry.npmjs.org/left-pad/-/left-pad-1.3.1.tgz",
+                "integrity": "sha512-upgraded=="
+            });
+            let mut live = fx.read_lock().await;
+            live["packages"]["node_modules/left-pad"] = upgraded.clone();
+            live["packages"]["node_modules/foo/node_modules/left-pad"] = upgraded;
+            tokio::fs::write(fx.lock_path(), serialize_json(&live, "  ").unwrap())
+                .await
+                .unwrap();
+
+            let outcome = revert_npm(&entry, fx.root(), false).await;
+            assert!(outcome.success, "{overrides}: {:?}", outcome.error);
+            assert!(
+                outcome.drift_skipped(),
+                "{overrides}: {:?}",
+                outcome.warnings
+            );
+            assert!(outcome.kept_artifact, "{overrides}: {:?}", outcome.warnings);
+        }
+    }
+
     #[test]
     fn legacy_pointer_maps_to_its_packages_key() {
         assert_eq!(
 
@@ -89,6 +89,23 @@ impl NpmOverrides {
         }
     }
 
+    /// True when any override rule, at any nesting depth, names the package
+    /// `name` (bare or with a selector). Coarser than [`Self::replacement`]
+    /// on purpose: a caller that must not trust an edge's registry
+    /// resolution while an override might swap it uses this.
+    pub(crate) fn mentions(&self, name: &str) -> bool {
+        fn walk(rules: &Map<String, Value>, name: &str) -> bool {
+            rules.iter().any(|(key, value)| {
+                let at = key
+                    .char_indices()
+                    .find_map(|(i, c)| (c == '@' && i > 0).then_some(i))
+                    .unwrap_or(key.len());
+                &key[..at] == name || value.as_object().is_some_and(|nested| walk(nested, name))
+            })
+        }
+        walk(&self.rules, name)
+    }
+
     /// The spec an override makes npm install for the edge `dep_name@spec`
     /// whose dependent sits at the lock key `from`, or `None` when no
     /// override clearly applies.