@@ -609,8 +609,10 @@ async fn verify_installed_tree(
             continue;
         };
         'copies: for copy in copies.get(purl).into_iter().flatten() {
-            for file in record.files.keys() {
-                if socket_patch_core::patch::apply::needs_npm_bin_rewrite(purl, copy, file).await {
+            for (file, info) in &record.files {
+                if socket_patch_core::patch::apply::needs_npm_bin_rewrite(purl, copy, file, info)
+                    .await
+                {
                     crlf_bins.push(purl.clone());
                     break 'copies;
                 }
 
@@ -1267,27 +1267,14 @@ async fn npm_agent_patches_crlf_shebang_bin_npm_rewrote() {
     let proj = crlf_bin_project(tmp.path());
     let cli = proj.join("node_modules/crlfbin/cli.js");
 
-    let run_bin = || {
-        std::process::Command::new(proj.join("node_modules/.bin/crlfbin"))
-            .current_dir(&proj)
-            .output()
-            .unwrap()
-    };
-
     let (code, stdout, stderr) = run_socket(&proj, &["apply", "--offline"]);
     assert_eq!(code, 0, "apply\nstdout:\n{stdout}\nstderr:\n{stderr}");
     assert!(
         !stderr.contains("did not match"),
         "no drift warning: {stderr}"
     );
     assert_eq!(std::fs::read(&cli).unwrap(), installed_after);
-    let ran = run_bin();
-    assert!(
-        ran.status.success(),
-        "{}",
-        npm_e2e_common::output_text(&ran)
-    );
-    assert_eq!(String::from_utf8_lossy(&ran.stdout).trim(), "hi");
+    assert_crlf_bin_runs(&proj, "after apply");
 
     let (code, stdout, stderr) = run_socket(&proj, &["apply", "--offline"]);
     assert_eq!(code, 0, "re-apply\nstdout:\n{stdout}\nstderr:\n{stderr}");
@@ -1315,12 +1302,7 @@ async fn npm_agent_patches_crlf_shebang_bin_npm_rewrote() {
     let (code, stdout, stderr) = run_socket(&proj, &["rollback", "--offline"]);
     assert_eq!(code, 0, "rollback\nstdout:\n{stdout}\nstderr:\n{stderr}");
     assert_eq!(std::fs::read(&cli).unwrap(), installed_before);
-    let ran = run_bin();
-    assert!(
-        ran.status.success(),
-        "{}",
-        npm_e2e_common::output_text(&ran)
-    );
+    assert_crlf_bin_runs(&proj, "after rollback");
 }
 
 /// Regression (#1791): v5.0.1 wrote the raw CRLF patched bytes over the
 
@@ -1026,8 +1026,13 @@ async fn mark_crlf_bin_rewrite(
 ) {
     if verify.status == VerifyStatus::AlreadyPatched
         && verify.current_hash.as_deref() == Some(file_info.after_hash.as_str())
-        && crate::patch::npm_bin::needs_fix(package_key, pkg_path, normalize_file_path(file_name))
-            .await
+        && crate::patch::npm_bin::needs_fix(
+            package_key,
+            pkg_path,
+            normalize_file_path(file_name),
+            &file_info.after_hash,
+        )
+        .await
     {
         verify.status = VerifyStatus::Ready;
         verify.target_hash = Some(file_info.after_hash.clone());
@@ -1036,12 +1041,24 @@ async fn mark_crlf_bin_rewrite(
 
 /// Whether `apply` would rewrite `file_name` (a manifest key) of the
 /// installed `package_key` copy at `pkg_path` although its bytes hash to
-/// the patched content: an npm bin left with a CRLF shebang `env` can't
-/// run (#1791). `apply --check` reports it as not applied.
-pub async fn needs_npm_bin_rewrite(package_key: &str, pkg_path: &Path, file_name: &str) -> bool {
+/// the patched content `file_info.after_hash`: an npm bin left with a
+/// CRLF shebang `env` can't run (#1791). `apply --check` reports it as
+/// not applied.
+pub async fn needs_npm_bin_rewrite(
+    package_key: &str,
+    pkg_path: &Path,
+    file_name: &str,
+    file_info: &PatchFileInfo,
+) -> bool {
     let normalized = normalize_file_path(file_name);
     is_safe_relative_subpath(normalized)
-        && crate::patch::npm_bin::needs_fix(package_key, pkg_path, normalized).await
+        && crate::patch::npm_bin::needs_fix(
+            package_key,
+            pkg_path,
+            normalized,
+            &file_info.after_hash,
+        )
+        .await
 }
 
 /// The single-copy apply engine behind [`apply_package_patch`]: verifies
@@ -4195,7 +4212,13 @@ mod tests {
         assert!(again.success, "{again:?}");
         assert!(again.files_patched.is_empty(), "{again:?}");
         assert!(
-            !needs_npm_bin_rewrite("pkg:npm/crlfbin@1.0.0", pkg.path(), "package/cli.js").await
+            !needs_npm_bin_rewrite(
+                "pkg:npm/crlfbin@1.0.0",
+                pkg.path(),
+                "package/cli.js",
+                &files["package/cli.js"]
+            )
+            .await
         );
     }
 
@@ -4223,7 +4246,15 @@ mod tests {
             tokio::fs::write(pkg.path().join("cli.js"), CRLF_BIN_AFTER)
                 .await
                 .unwrap();
-            assert!(!needs_npm_bin_rewrite(purl, pkg.path(), "package/cli.js").await);
+            assert!(
+                !needs_npm_bin_rewrite(
+                    purl,
+                    pkg.path(),
+                    "package/cli.js",
+                    &files["package/cli.js"]
+                )
+                .await
+            );
             let res = apply_package_patch(
                 purl,
                 pkg.path(),
 
@@ -81,6 +81,10 @@ pub(crate) async fn form_for_write<'a>(
     expected_hash: &str,
 ) -> Result<(std::borrow::Cow<'a, [u8]>, String), std::io::Error> {
     let as_recorded = |content| Ok((content, expected_hash.to_string()));
+    // Content `fixBin` leaves alone needs no evidence read from disk.
+    if fix_bin(&content).is_none() {
+        return as_recorded(content);
+    }
     let path = pkg_path.join(normalized);
     let npm_installed = is_listed_bin(package_key, pkg_path, normalized).await || {
         let lf_shebang = read_prefix(&path)
@@ -119,11 +123,17 @@ pub(crate) async fn is_listed_bin(package_key: &str, pkg_path: &Path, normalized
     lists_bin(&manifest, normalized)
 }
 
-/// Whether the file holding raw bytes `fixBin` would change (a CRLF
-/// shebang npm never leaves in a bin) is a bin of the npm package
-/// `package_key`: the state a release before #1756 left by writing the
-/// recorded bytes over npm's form, which `env` can't run (#1791).
-pub(crate) async fn needs_fix(package_key: &str, pkg_path: &Path, normalized: &str) -> bool {
+/// Whether the file at `normalized` holds exactly the recorded content
+/// `expected_hash`, in bytes `fixBin` would change (a CRLF shebang npm
+/// never leaves in a bin), and is a bin of the npm package `package_key`:
+/// the state a release before #1756 left by writing the recorded bytes
+/// over npm's form, which `env` can't run (#1791).
+pub(crate) async fn needs_fix(
+    package_key: &str,
+    pkg_path: &Path,
+    normalized: &str,
+    expected_hash: &str,
+) -> bool {
     if !is_npm(package_key) {
         return false;
     }
@@ -139,36 +149,51 @@ pub(crate) async fn needs_fix(package_key: &str, pkg_path: &Path, normalized: &s
     }
     crate::utils::fs::read_regular_to_bytes(&path)
         .await
-        .is_ok_and(|bytes| fix_bin(&bytes).is_some())
+        .is_ok_and(|bytes| {
+            fix_bin(&bytes).is_some() && compute_git_sha256_from_bytes(&bytes) == expected_hash
+        })
 }
 
 /// Whether the `package.json` bytes `manifest` list `normalized` as a
-/// bin: a `bin` path (string or object values) or, with no `bin`, a file
-/// under `directories.bin`, as npm's `normalize` reads them. Paths are
-/// resolved as npm does (`./` and `..` folded, never above the package).
+/// bin, as npm's `normalize-package-bin` and `directories.bin` step read
+/// them: a `bin` path (a string, when the package has a `name`, an
+/// object's values, or an array's entries) or, when `bin` is missing or
+/// empty, a non-hidden file under `directories.bin`. Paths are resolved
+/// as npm does (`./` and `..` folded, never above the package).
 fn lists_bin(manifest: &[u8], normalized: &str) -> bool {
-    let Ok(json) = serde_json::from_slice::<serde_json::Value>(manifest) else {
+    use serde_json::Value;
+    let Ok(json) = serde_json::from_slice::<Value>(manifest) else {
         return false;
     };
     let target = clean_path(normalized);
     if target.is_empty() {
         return false;
     }
+    let lists = |bins: &mut dyn Iterator<Item = &Value>| {
+        bins.filter_map(Value::as_str)
+            .any(|bin| clean_path(bin) == target)
+    };
     match json.get("bin") {
-        Some(serde_json::Value::String(bin)) => clean_path(bin) == target,
-        Some(serde_json::Value::Object(bins)) => bins
-            .values()
-            .filter_map(serde_json::Value::as_str)
-            .any(|bin| clean_path(bin) == target),
-        Some(_) => false,
-        None => json
+        Some(Value::String(bin)) if !bin.is_empty() => {
+            json.get("name")
+                .and_then(Value::as_str)
+                .is_some_and(|n| !n.is_empty())
+                && clean_path(bin) == target
+        }
+        Some(Value::Object(bins)) => lists(&mut bins.values()),
+        Some(Value::Array(bins)) => lists(&mut bins.iter()),
+        Some(Value::String(_) | Value::Null | Value::Bool(false)) | None => json
             .get("directories")
             .and_then(|d| d.get("bin"))
             .and_then(serde_json::Value::as_str)
             .map(clean_path)
             .is_some_and(|dir| {
-                !dir.is_empty() && target.len() > dir.len() && target.starts_with(&dir[..])
+                !dir.is_empty()
+                    && target.len() > dir.len()
+                    && target.starts_with(&dir[..])
+                    && !target[dir.len()..].iter().any(|seg| seg.starts_with('.'))
             }),
+        Some(_) => false,
     }
 }
 
@@ -344,8 +369,8 @@ mod tests {
     #[test]
     fn lists_bin_reads_every_bin_shape() {
         let listed = |manifest: &str, file: &str| lists_bin(manifest.as_bytes(), file);
-        assert!(listed(r#"{"bin":"cli.js"}"#, "cli.js"));
-        assert!(listed(r#"{"bin":"./bin/../cli.js"}"#, "cli.js"));
+        assert!(listed(r#"{"name":"x","bin":"cli.js"}"#, "cli.js"));
+        assert!(listed(r#"{"name":"x","bin":"./bin/../cli.js"}"#, "cli.js"));
         assert!(listed(
             r#"{"bin":{"a":"x.js","b":"./bin/cli.js"}}"#,
             "bin/cli.js"
@@ -360,6 +385,19 @@ mod tests {
             "bin/cli.js"
         ));
         assert!(!listed(r#"{"bin":{"a":"x.js"}}"#, "cli.js"));
+        assert!(listed(r#"{"bin":["x.js","./cli.js"]}"#, "cli.js"));
+        // npm drops a string `bin` of a package with no name.
+        assert!(!listed(r#"{"bin":"cli.js"}"#, "cli.js"));
+        // A missing or empty `bin` falls back to `directories.bin`, whose
+        // glob skips hidden files.
+        for bin in ["\"\"", "null"] {
+            let manifest = format!(r#"{{"bin":{bin},"directories":{{"bin":"bin"}}}}"#);
+            assert!(listed(&manifest, "bin/cli.js"), "{manifest}");
+        }
+        assert!(!listed(
+            r#"{"directories":{"bin":"bin"}}"#,
+            "bin/.hidden/cli.js"
+        ));
         assert!(!listed(r#"{"name":"x"}"#, "cli.js"));
         assert!(!listed(r#"{"directories":{"bin":"."}}"#, "cli.js"));
         assert!(!listed("not json", "cli.js"));
 
@@ -573,6 +573,38 @@ async fn remove_dir_if_empty(dir: &Path) -> bool {
 /// The single-copy rollback engine behind [`rollback_package_patch`]:
 /// verifies and rolls back the package at exactly the one `pkg_path` it is
 /// given.
+/// A bin of an npm package holding the raw original bytes with their CRLF
+/// shebang, which a rollback before #1756 wrote over npm's form, can't be
+/// run by `env`: `Ready`, so the restore writes npm's form of the
+/// original (#1791). Only with the before blob at hand: a finished
+/// rollback never fails for want of one.
+async fn mark_crlf_bin_rewrite(
+    package_key: &str,
+    pkg_path: &Path,
+    file_name: &str,
+    file_info: &PatchFileInfo,
+    blobs_path: &Path,
+    verify: &mut VerifyRollbackResult,
+) {
+    if verify.status == VerifyRollbackStatus::AlreadyOriginal
+        && !file_info.before_hash.is_empty()
+        && verify.current_hash.as_deref() == Some(file_info.before_hash.as_str())
+        && crate::patch::apply::is_valid_blob_hash(&file_info.before_hash)
+        && tokio::fs::symlink_metadata(blobs_path.join(&file_info.before_hash))
+            .await
+            .is_ok_and(|m| m.is_file())
+        && crate::patch::npm_bin::needs_fix(
+            package_key,
+            pkg_path,
+            normalize_file_path(file_name),
+            &file_info.before_hash,
+        )
+        .await
+    {
+        verify.status = VerifyRollbackStatus::Ready;
+    }
+}
+
 async fn rollback_package_patch_at(
     package_key: &str,
     pkg_path: &Path,
@@ -592,7 +624,17 @@ async fn rollback_package_patch_at(
 
     // First, verify all files
     for (file_name, file_info) in files_in_order(files) {
-        let verify_result = verify_file_rollback(pkg_path, file_name, file_info, blobs_path).await;
+        let mut verify_result =
+            verify_file_rollback(pkg_path, file_name, file_info, blobs_path).await;
+        mark_crlf_bin_rewrite(
+            package_key,
+            pkg_path,
+            file_name,
+            file_info,
+            blobs_path,
+            &mut verify_result,
+        )
+        .await;
 
         // If any file has issues (not ready and not already original), we can't proceed
         if verify_result.status != VerifyRollbackStatus::Ready
@@ -3234,6 +3276,55 @@ mod tests {
         );
     }
 
+    /// Regression (#1791): a bin an earlier rollback left with the raw
+    /// CRLF original is rewritten in npm's runnable form when the before
+    /// blob is there, and left alone, as already original, when it isn't.
+    #[tokio::test]
+    async fn rollback_rewrites_raw_crlf_original_bin() {
+        let before: &[u8] = b"#!/usr/bin/env node\r\nconsole.log(1);\r\n";
+        let after: &[u8] = b"#!/usr/bin/env node\r\nconsole.log(2);\r\n";
+        let before_hash = compute_git_sha256_from_bytes(before);
+        let files = HashMap::from([(
+            "package/cli.js".to_string(),
+            PatchFileInfo {
+                before_hash: before_hash.clone(),
+                after_hash: compute_git_sha256_from_bytes(after),
+            },
+        )]);
+        for with_blob in [true, false] {
+            let pkg = tempfile::tempdir().unwrap();
+            let blobs = tempfile::tempdir().unwrap();
+            if with_blob {
+                tokio::fs::write(blobs.path().join(&before_hash), before)
+                    .await
+                    .unwrap();
+            }
+            tokio::fs::write(
+                pkg.path().join("package.json"),
+                br#"{"name":"x","version":"1.0.0","bin":"cli.js"}"#,
+            )
+            .await
+            .unwrap();
+            tokio::fs::write(pkg.path().join("cli.js"), before)
+                .await
+                .unwrap();
+            let res =
+                rollback_package_patch("pkg:npm/x@1.0.0", pkg.path(), &files, blobs.path(), false)
+                    .await;
+            assert!(res.success, "{with_blob}: {res:?}");
+            let expected: &[u8] = if with_blob {
+                b"#!/usr/bin/env node\nconsole.log(1);\r\n"
+            } else {
+                before
+            };
+            assert_eq!(
+                tokio::fs::read(pkg.path().join("cli.js")).await.unwrap(),
+                expected,
+                "{with_blob}"
+            );
+        }
+    }
+
     /// Regression (#1756): a bin the patch added, installed by npm in its
     /// LF-shebang form, rolls back (is deleted) like the exact bytes.
     #[tokio::test]