@@ -95,7 +95,8 @@ into the new version's section — see docs/releasing.md.
   restore <purl> to its upstream registry entry: <why>; restore it from
   version control instead (`git checkout -- <files>`)`: every pin under
   `--offline` except Maven, a registry that does not answer or no longer
-  describes the entry, a binary `bun.lockb` (always), a composer entry that
+  describes the entry, a binary `bun.lockb` (for `rollback` / `remove`; see
+  the vendor takeover below), a composer entry that
   is not packagist-sourced or whose `dist.reference` packagist no longer
   serves, a gem whose upstream section is ambiguous or not rubygems.org, a
   nuget id the restored config would not resolve from nuget.org alone, a
@@ -183,6 +184,21 @@ into the new version's section — see docs/releasing.md.
   live hosted pin: …`) and leaves it hosted. The cargo backend's
   `hosted_redirect_live` refusal now names `socket-patch rollback` and
   `git checkout -- Cargo.toml Cargo.lock` instead of the ledger.
+- **Vendoring over a hosted binary `bun.lockb` works again** (Bun 0.8–1.1's
+  default lock and Bun 1.2's legacy lock; it was refused
+  `redirect_revert_failed` once the hosted ledger was gone). The takeover
+  and the eject rebuild each hosted remote-tarball record as Bun's npm
+  registry record for `name@version` from the registry's `dist.tarball` /
+  `dist.integrity`, re-derive the package metadata hash, drop the hosted
+  URL from the string pool, then vendor; `vendor --revert` returns the
+  pre-hosted lock. The hosted rewrite now keeps the registry record's
+  inactive bytes (padding, semver) in the tarball record it writes, and a
+  re-pin to a later grant's URL drops the superseded URL from the string
+  pool, so the rebuild is byte-exact — early writers' uninitialized padding included —
+  except for a binary format 1 lock (kept promoted to format 2) and a
+  workspace lock (dependency behaviors kept normalized). Those exceptions
+  keep `rollback` / `remove` refusing a hosted `bun.lockb` pin with the
+  `git checkout -- bun.lockb` remedy; an `--offline` vendor still refuses.
 - **`vendor_supersedes_redirect` is removed.** The vendored flows no longer
   warn about (or auto-reconcile, or unwind the `.npmrc` for) a stale hosted
   ledger record: once the lock routes a package to `.socket/vendor/`, no
 
@@ -351,9 +351,9 @@ clean tree and an empty store, then check with `socket-patch vex`. See
 
 Both text `bun.lock` and binary `bun.lockb` support hosted and vendored
 patches, mode switching, repair, and rollback — with one exception: a hosted
-`bun.lockb` entry cannot be restored to its upstream registry entry, so
-`rollback`, `remove` and switching it to vendored mode refuse it and point you at
-`git checkout -- bun.lockb`. Binary locks are read and
+`bun.lockb` entry is not rolled back to its upstream registry entry, so
+`rollback` and `remove` refuse it and point you at `git checkout -- bun.lockb`
+(switching it to vendored mode rebuilds the registry entry and works). Binary locks are read and
 patched natively: Socket Patch does not need Bun installed to discover or
 rewrite them, and does not convert them to text. If both filenames exist,
 `bun.lock` takes precedence. See [Bun compatibility](docs/testing/bun-compatibility.md)
 
@@ -1057,6 +1057,9 @@ pub(crate) async fn run_hosted_leg(common: &GlobalArgs, pins: &[HostedPin]) -> H
         dry_run: common.dry_run,
         offline: common.offline,
         patch_server_origins: origins,
+        // A binary bun.lockb pin refuses with the checkout remedy: its
+        // rebuilt registry record is not byte-exact for every lock.
+        bun_lockb: false,
     };
     let outcome = restore_upstream(&common.cwd, pins, &opts).await;
     for pin in &outcome.pins {
 
@@ -1123,6 +1123,7 @@ async fn run_eject(args: &VendorArgs, pins: Vec<HostedPin>) -> i32 {
             dry_run: true,
             offline: common.offline,
             patch_server_origins: origins.clone(),
+            bun_lockb: true,
         },
     )
     .await;
@@ -1222,6 +1223,7 @@ async fn run_eject(args: &VendorArgs, pins: Vec<HostedPin>) -> i32 {
             dry_run: false,
             offline: common.offline,
             patch_server_origins: origins,
+            bun_lockb: true,
         },
     )
     .await;
@@ -2954,6 +2956,7 @@ pub(crate) async fn vendor_records_reusing(
                         dry_run: common.dry_run,
                         offline: common.offline,
                         patch_server_origins: origins,
+                        bun_lockb: true,
                     },
                 )
                 .await;
 
@@ -1,9 +1,9 @@
 //! Real Bun binary-lock acceptance tests. The CLI must never invoke a Bun
 //! conversion or replace bun.lockb with text. Every terminal mode is checked
 //! with an empty-cache frozen install, and rollback restores the exact input
-//! (v5: a hosted pin in a binary lock is refused by rollback and by a vendor
-//! takeover — only bun can re-encode its upstream entry — and restored from
-//! version control instead).
+//! (v5: a hosted pin in a binary lock is refused by rollback — restored from
+//! version control instead — while a vendor takeover rebuilds its registry
+//! record from the npm registry, refusing only offline).
 //!
 //! Run scripts/backtest-bun-lockb.py for the writer/reader release matrix.
 //! SOCKET_PATCH_BUN_LOCKB_REQUIRED=1 makes missing tools a hard error;
@@ -65,8 +65,14 @@ fn require_success(output: Output, label: &str) -> Output {
 }
 
 fn cli(project: &Path, args: &[&str]) -> Value {
+    cli_env(project, args, &[])
+}
+
+/// [`cli`] with extra environment variables.
+fn cli_env(project: &Path, args: &[&str], envs: &[(&str, &str)]) -> Value {
     let output = require_success(
         command(env!("CARGO_BIN_EXE_socket-patch"), project)
+            .envs(envs.iter().copied())
             .args(args)
             .args([
                 "--cwd",
@@ -110,10 +116,10 @@ fn cli_code(project: &Path, args: &[&str]) -> (i32, Value) {
 }
 
 /// v5 keeps no hosted ledger, so undoing a hosted pin means restoring the
-/// entry's upstream registry form — which a binary `bun.lockb` cannot get
-/// from socket-patch (only bun can re-encode it). `rollback` therefore
-/// REFUSES the pin, naming the checkout remedy, and leaves the lock exactly
-/// as found; the test then applies that remedy (`git checkout --
+/// entry's upstream registry form. For a binary `bun.lockb` that rebuilt
+/// record is not byte-exact for every lock (format 1, workspace locks), so
+/// `rollback` REFUSES the pin, naming the checkout remedy, and leaves the
+/// lock exactly as found; the test then applies that remedy (`git checkout --
 /// bun.lockb`, here: the original bytes written back).
 fn rollback_refuses_binary_hosted_pin_then_checkout(fixture: &Fixture, server: &MockServer) {
     let hosted_lock = fixture.lock();
@@ -743,10 +749,13 @@ async fn native_binary_hosted_vendored_takeover_roundtrip() {
     std::fs::rename(&modules, project.join("node_modules")).unwrap();
 
     // Hosted -> vendored: v5 restores a hosted pin's upstream entry before
-    // vendoring over it, which a binary bun.lockb cannot get — the takeover
-    // is REFUSED (dry and wet alike, nothing written) with the checkout
-    // remedy. After `git checkout -- bun.lockb` the vendor proceeds, with a
-    // truthful dry run and exact rerun state.
+    // vendoring over it, re-resolving the registry record from the npm
+    // registry — which an OFFLINE takeover cannot do, so it is REFUSED (dry
+    // and wet alike, nothing written) with the checkout remedy. Online, the
+    // takeover rebuilds the binary registry record exactly and vendors over
+    // it; `vendor --revert` then gives back the original bytes. After that
+    // (equivalently, after `git checkout -- bun.lockb`) the offline vendor
+    // proceeds, with a truthful dry run and exact rerun state.
     fixture.stage();
     let uri = server.uri();
     let before = snapshot(project);
@@ -780,7 +789,69 @@ async fn native_binary_hosted_vendored_takeover_roundtrip() {
             "refused vendor {extra:?} wrote nothing"
         );
     }
-    std::fs::write(project.join("bun.lockb"), &fixture.original_lock).unwrap();
+    // The npm registry's version document for minimist@1.2.2 (the public
+    // registry's values, which the original lock pins), served locally.
+    let integrity = "sha512-rIqbOrKb8GJmx/5bc2M0QchhUouMXSpd1RTclXsB41JdL+VtnojfaJR+h7F9k18/4kHUsBFgk80Uk+q569vjPA==";
+    let digest = base64::engine::general_purpose::STANDARD
+        .decode(integrity.trim_start_matches("sha512-"))
+        .unwrap();
+    assert!(
+        fixture.original_lock.windows(64).any(|w| w == digest.as_slice()),
+        "the original lock pins the registry digest"
+    );
+    Mock::given(method("GET"))
+        .and(path("/minimist/1.2.2"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"dist": {
+            "tarball": "https://registry.npmjs.org/minimist/-/minimist-1.2.2.tgz",
+            "integrity": integrity}})))
+        .mount(&server)
+        .await;
+    let taken_over = cli_env(
+        project,
+        &["vendor", "--patch-server-url", &uri, "--vendor-source", "build"],
+        &[("SOCKET_NPM_REGISTRY", &uri)],
+    );
+    assert_eq!(
+        taken_over["summary"]["applied"], 1,
+        "online vendor over the binary hosted pin: {taken_over}"
+    );
+    assert!(
+        taken_over["events"].as_array().is_some_and(|events| events
+            .iter()
+            .any(|e| e["errorCode"] == "vendor_takeover_reverted_redirect")),
+        "the takeover is reported: {taken_over}"
+    );
+    let vendor_lock = fixture.lock();
+    assert!(
+        !vendor_lock
+            .windows(uri.len())
+            .any(|w| w == uri.as_bytes()),
+        "no hosted URL is left in bun.lockb"
+    );
+    let state: Value = serde_json::from_slice(
+        &std::fs::read(project.join(".socket/vendor/state.json")).unwrap(),
+    )
+    .unwrap();
+    let original = state["entries"][PURL]["wiring"]
+        .as_array()
+        .and_then(|w| w.iter().find(|r| r["kind"] == "bun_lockb_package"))
+        .map(|r| r["original"].clone())
+        .unwrap_or_else(|| panic!("bun_lockb_package wiring: {state}"));
+    assert_eq!(original["name"], "minimist", "{original}");
+    assert_eq!(original["version"], "1.2.2", "{original}");
+    assert_eq!(
+        original["resolution"],
+        "https://registry.npmjs.org/minimist/-/minimist-1.2.2.tgz",
+        "the vendor ledger records the registry record: {original}"
+    );
+    fixture.frozen("taken-over", &fixture.patched, "minimist");
+    let reverted = cli(project, &["vendor", "--revert", "--offline"]);
+    assert_eq!(
+        fixture.lock(),
+        fixture.original_lock,
+        "the revert restores the pre-hosted bytes exactly: {reverted}"
+    );
+    assert!(!project.join(".socket/vendor").exists(), "{reverted}");
     let before = snapshot(project);
     let preview = cli(project, &["vendor", "--offline", "--dry-run"]);
     assert_eq!(snapshot(project), before, "vendor dry run: {preview}");