@@ -251,6 +251,17 @@ enum HostedDriver {
     GetUuid,
 }
 
+/// The project the fixture installs.
+#[derive(Clone, Copy, PartialEq, Debug)]
+enum Layout {
+    /// One manifest depending on `left-pad@1.3.0`.
+    Single,
+    /// #1271: a yarn workspace whose member `a` declares `"left-pad": ""`
+    /// (an empty range, the same as `*`) and member `b` `"^1.3.0"`, so yarn
+    /// locks both under one `left-pad@, left-pad@^1.3.0:` block.
+    EmptyRangeWorkspace,
+}
+
 /// Where the fixture configures `yarn-offline-mirror`.
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum Mirror {
@@ -278,6 +289,7 @@ async fn classic_hosted_project(
     tamper_served_tarball: bool,
     mirror: Mirror,
     driver: HostedDriver,
+    layout: Layout,
 ) -> Option<ClassicRedirectFixture> {
     let offline_mirror = mirror != Mirror::None;
     if !require_yarn_classic(&format!("e2e_redirect_yarn_classic_build ({tag})"), |c| {
@@ -288,13 +300,32 @@ async fn classic_hosted_project(
     let tmp = tempfile::tempdir().unwrap();
     let proj = tmp.path().join("proj");
     std::fs::create_dir_all(&proj).unwrap();
-    std::fs::write(
-        proj.join("package.json"),
-        format!(
-            r#"{{"name":"redirect-classic-capstone","version":"0.0.0","private":true,"dependencies":{{"{DEP}":"{DEP_VERSION}"}}}}"#
-        ),
-    )
-    .unwrap();
+    match layout {
+        Layout::Single => std::fs::write(
+            proj.join("package.json"),
+            format!(
+                r#"{{"name":"redirect-classic-capstone","version":"0.0.0","private":true,"dependencies":{{"{DEP}":"{DEP_VERSION}"}}}}"#
+            ),
+        )
+        .unwrap(),
+        Layout::EmptyRangeWorkspace => {
+            std::fs::write(
+                proj.join("package.json"),
+                r#"{"name":"redirect-classic-capstone","version":"0.0.0","private":true,"workspaces":["a","b"]}"#,
+            )
+            .unwrap();
+            for (member, range) in [("a", ""), ("b", "^1.3.0")] {
+                std::fs::create_dir_all(proj.join(member)).unwrap();
+                std::fs::write(
+                    proj.join(member).join("package.json"),
+                    format!(
+                        r#"{{"name":"{member}","version":"1.0.0","dependencies":{{"{DEP}":"{range}"}}}}"#
+                    ),
+                )
+                .unwrap();
+            }
+        }
+    }
     let mirror_dir = proj.join("mirror");
     let mirror_dir = mirror_dir.to_str().unwrap();
     // Where yarn reads the mirror from; the env leg sets it for yarn AND
@@ -356,6 +387,12 @@ async fn classic_hosted_project(
         lock_pristine.contains("# yarn lockfile v1"),
         "fixture must be a yarn classic v1 lock:\n{lock_pristine}"
     );
+    if layout == Layout::EmptyRangeWorkspace {
+        assert!(
+            lock_pristine.contains(&format!("\n{DEP}@, {DEP}@^1.3.0:\n")),
+            "yarn must merge the empty range into one block:\n{lock_pristine}"
+        );
+    }
 
     // 2. Patched tarball + the exact hashes classic will verify at install.
     let tgz_path = tmp.path().join(format!("{DEP}-{DEP_VERSION}.tgz"));
@@ -591,6 +628,14 @@ fn fresh_checkout_yarn_install(fx: &ClassicRedirectFixture) -> (PathBuf, Output)
     std::fs::create_dir_all(&fresh).unwrap();
     std::fs::copy(fx.proj.join("package.json"), fresh.join("package.json")).unwrap();
     std::fs::copy(fx.proj.join("yarn.lock"), fresh.join("yarn.lock")).unwrap();
+    // Workspace members' manifests (Layout::EmptyRangeWorkspace).
+    for member in ["a", "b"] {
+        let manifest = fx.proj.join(member).join("package.json");
+        if manifest.is_file() {
+            std::fs::create_dir_all(fresh.join(member)).unwrap();
+            std::fs::copy(manifest, fresh.join(member).join("package.json")).unwrap();
+        }
+    }
     // v5 hosted mode writes nothing under `.socket/`; carry it when present.
     if fx.proj.join(".socket").is_dir() {
         copy_dir_recursive(&fx.proj.join(".socket"), &fresh.join(".socket"));
@@ -773,7 +818,14 @@ fn hosted_dev_resave_vex(fx: &ClassicRedirectFixture) {
 #[tokio::test(flavor = "multi_thread")]
 #[serial_test::serial]
 async fn classic_redirect_fresh_checkout_installs_patched_bytes() {
-    let Some(fx) = classic_hosted_project("main", false, Mirror::None, HostedDriver::Scan).await
+    let Some(fx) = classic_hosted_project(
+        "main",
+        false,
+        Mirror::None,
+        HostedDriver::Scan,
+        Layout::Single,
+    )
+    .await
     else {
         return;
     };
@@ -802,6 +854,41 @@ async fn classic_redirect_fresh_checkout_installs_patched_bytes() {
     tokio::task::block_in_place(|| hosted_dev_resave_vex(&fx));
 }
 
+/// #1271: yarn 1 locks a member's `"left-pad": ""` (an empty range) under
+/// one `left-pad@, left-pad@^1.3.0:` block with the other member's range.
+/// That block is the installed registry copy: the hosted scan pins it (the
+/// fixture asserts one redirect and the lock pin), and a fresh checkout
+/// installs the patched bytes for both members.
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn classic_empty_range_workspace_key_is_pinned() {
+    let Some(fx) = classic_hosted_project(
+        "empty-range",
+        false,
+        Mirror::None,
+        HostedDriver::Scan,
+        Layout::EmptyRangeWorkspace,
+    )
+    .await
+    else {
+        return;
+    };
+    let lock = std::fs::read_to_string(fx.proj.join("yarn.lock")).unwrap();
+    assert!(
+        lock.contains(&format!("\n{DEP}@, {DEP}@^1.3.0:\n")),
+        "the pin keeps the key line:\n{lock}"
+    );
+    let (fresh, ci) = fresh_checkout_yarn_install(&fx);
+    assert!(
+        ci.status.success(),
+        "fresh-checkout install must succeed.\nstdout:\n{}\nstderr:\n{}",
+        String::from_utf8_lossy(&ci.stdout),
+        String::from_utf8_lossy(&ci.stderr),
+    );
+    let installed = std::fs::read(fresh.join("node_modules").join(DEP).join("index.js")).unwrap();
+    assert_eq!(installed, fx.patched, "both members load the patched bytes");
+}
+
 /// get-driven hosted twin (v4.0): `get <uuid> --mode hosted --json --yes`
 /// routes through the SAME hosted engine as `scan --mode hosted`, so the
 /// classic chain must hold unchanged — the fixture's lock pin (hosted URL +
@@ -813,8 +900,14 @@ async fn classic_redirect_fresh_checkout_installs_patched_bytes() {
 #[tokio::test(flavor = "multi_thread")]
 #[serial_test::serial]
 async fn classic_get_uuid_hosted_fresh_checkout_installs() {
-    let Some(fx) =
-        classic_hosted_project("get-uuid", false, Mirror::None, HostedDriver::GetUuid).await
+    let Some(fx) = classic_hosted_project(
+        "get-uuid",
+        false,
+        Mirror::None,
+        HostedDriver::GetUuid,
+        Layout::Single,
+    )
+    .await
     else {
         return;
     };
@@ -847,7 +940,14 @@ async fn classic_get_uuid_hosted_fresh_checkout_installs() {
 #[tokio::test(flavor = "multi_thread")]
 #[serial_test::serial]
 async fn classic_redirect_tampered_hosted_tarball_fails_integrity() {
-    let Some(fx) = classic_hosted_project("tampered", true, Mirror::None, HostedDriver::Scan).await
+    let Some(fx) = classic_hosted_project(
+        "tampered",
+        true,
+        Mirror::None,
+        HostedDriver::Scan,
+        Layout::Single,
+    )
+    .await
     else {
         return;
     };
@@ -894,6 +994,7 @@ async fn classic_offline_mirror_refuses_hosted_and_keeps_installs_working() {
         false,
         Mirror::ProjectRc,
         HostedDriver::Scan,
+        Layout::Single,
     )
     .await
     else {
@@ -975,7 +1076,9 @@ async fn classic_offline_mirror_outside_project_rc_refuses_hosted() {
         ("offline-mirror-parent", Mirror::ParentRc),
         ("offline-mirror-env", Mirror::Env),
     ] {
-        let Some(fx) = classic_hosted_project(tag, false, mirror, HostedDriver::Scan).await else {
+        let Some(fx) =
+            classic_hosted_project(tag, false, mirror, HostedDriver::Scan, Layout::Single).await
+        else {
             continue;
         };
         assert!(
 
@@ -66,12 +66,38 @@ pub(crate) fn split_pattern(pattern: &str) -> Option<(&str, &str)> {
     Some((name, range))
 }
 
+/// Split a classic key pattern `name@range` like [`split_pattern`], but
+/// keep an EMPTY range (#1271): `""` is valid npm semver (the same as `*`),
+/// and yarn 1 locks `"left-pad": ""` under `left-pad@:` — merged with other
+/// ranges as `left-pad@, left-pad@^1.3.0:`. Berry never writes a rangeless
+/// descriptor (its ranges carry a protocol), so the berry readers keep the
+/// strict [`split_pattern`] and treat `name@` as malformed.
+pub(crate) fn split_classic_pattern(pattern: &str) -> Option<(&str, &str)> {
+    let from = usize::from(pattern.starts_with('@'));
+    let at = pattern[from..].find('@')? + from;
+    let (name, range) = (&pattern[..at], &pattern[at + 1..]);
+    if name.is_empty() {
+        return None;
+    }
+    Some((name, range))
+}
+
 /// The real package a key pattern stands for: its name, unless the range is
 /// an `npm:` alias — then the aliased target's name.
 pub(crate) fn pattern_real_name(pattern: &str) -> Option<&str> {
-    let (name, range) = split_pattern(pattern)?;
+    real_name_with(pattern, split_pattern)
+}
+
+/// [`pattern_real_name`] over the classic grammar ([`split_classic_pattern`]):
+/// a rangeless `left-pad@` stands for `left-pad`.
+pub(crate) fn classic_pattern_real_name(pattern: &str) -> Option<&str> {
+    real_name_with(pattern, split_classic_pattern)
+}
+
+fn real_name_with(pattern: &str, split: fn(&str) -> Option<(&str, &str)>) -> Option<&str> {
+    let (name, range) = split(pattern)?;
     if let Some(aliased) = range.strip_prefix("npm:") {
-        return match split_pattern(aliased) {
+        return match split(aliased) {
             Some((real, _)) => Some(real),
             None => Some(aliased), // `npm:left-pad` with no range
         };
@@ -80,10 +106,10 @@ pub(crate) fn pattern_real_name(pattern: &str) -> Option<&str> {
 }
 
 /// The one real package EVERY pattern of a classic key stands for
-/// ([`pattern_real_name`]): `None` when there is no pattern, one does not
-/// parse, or they name different packages.
+/// ([`classic_pattern_real_name`]): `None` when there is no pattern, one
+/// does not parse, or they name different packages.
 pub(crate) fn classic_key_real_name(patterns: &[String]) -> Option<&str> {
-    let mut names = patterns.iter().map(|p| pattern_real_name(p));
+    let mut names = patterns.iter().map(|p| classic_pattern_real_name(p));
     let first = names.next()??;
     names.all(|n| n == Some(first)).then_some(first)
 }
@@ -169,6 +195,36 @@ pub(crate) fn berry_npm_alias_target(range: &str) -> Option<&str> {
 mod tests {
     use super::*;
 
+    /// #1271: the classic grammar keeps an empty range (`left-pad@` from
+    /// `"left-pad": ""`); the strict berry grammar still rejects it.
+    #[test]
+    fn classic_patterns_keep_an_empty_range() {
+        assert_eq!(split_classic_pattern("left-pad@"), Some(("left-pad", "")));
+        assert_eq!(
+            split_classic_pattern("@scope/pkg@"),
+            Some(("@scope/pkg", ""))
+        );
+        assert_eq!(
+            split_classic_pattern("left-pad@^1.3.0"),
+            Some(("left-pad", "^1.3.0"))
+        );
+        assert_eq!(split_classic_pattern("@scope/pkg"), None);
+        assert_eq!(split_classic_pattern("left-pad"), None);
+        assert_eq!(split_classic_pattern("@"), None);
+        assert_eq!(split_pattern("left-pad@"), None);
+
+        assert_eq!(classic_pattern_real_name("left-pad@"), Some("left-pad"));
+        assert_eq!(
+            classic_pattern_real_name("lp@npm:left-pad@"),
+            Some("left-pad")
+        );
+        let merged = split_key_patterns("left-pad@, left-pad@^1.3.0");
+        assert_eq!(merged, ["left-pad@", "left-pad@^1.3.0"]);
+        assert_eq!(classic_key_real_name(&merged), Some("left-pad"));
+        let quoted = split_key_patterns("\"@scope/pkg@\", \"@scope/pkg@^1.0.0\"");
+        assert_eq!(classic_key_real_name(&quoted), Some("@scope/pkg"));
+    }
+
     #[test]
     fn resolution_selector_targets() {
         for (sel, want) in [
 
@@ -1,7 +1,7 @@
 //! Where yarn 1 installs a classic lock block's copy from, decided once for
 //! every mode that reads or rewrites the block.
 
-use super::patterns::split_pattern;
+use super::patterns::split_classic_pattern;
 use crate::vendor::npm_origin::npm_spec_is_registry;
 
 /// Where yarn 1 installs a lock block's copy from: the ONE classifier every
@@ -48,7 +48,7 @@ pub(crate) enum CopySource {
 /// [`CopySource`] of a classic block from its key patterns and `resolved`.
 pub(crate) fn classic_copy_source(patterns: &[String], resolved: Option<&str>) -> CopySource {
     for pattern in patterns {
-        let range = split_pattern(pattern).map(|(_, r)| r).unwrap_or("");
+        let range = split_classic_pattern(pattern).map(|(_, r)| r).unwrap_or("");
         if range.starts_with("link:") {
             return CopySource::Link;
         }
@@ -66,7 +66,7 @@ pub(crate) fn classic_copy_source(patterns: &[String], resolved: Option<&str>) -
     };
     let registry_ranges = patterns
         .iter()
-        .all(|p| split_pattern(p).is_some_and(|(_, range)| npm_spec_is_registry(range)));
+        .all(|p| split_classic_pattern(p).is_some_and(|(_, range)| npm_spec_is_registry(range)));
     if registry_ranges && !is_codeload_tarball(resolved) {
         CopySource::Registry
     } else {
@@ -81,7 +81,7 @@ pub(crate) fn classic_copy_source(patterns: &[String], resolved: Option<&str>) -
 /// a path that leaves the root.
 pub(crate) fn classic_file_directory(patterns: &[String]) -> Option<String> {
     patterns.iter().find_map(|p| {
-        let path = split_pattern(p)?.1.strip_prefix("file:")?;
+        let path = split_classic_pattern(p)?.1.strip_prefix("file:")?;
         let path = path.split('#').next().unwrap_or_default();
         if is_tarball_path(path) {
             return None;
@@ -180,9 +180,9 @@ fn is_codeload_tarball(resolved: &str) -> bool {
 /// here: yarn locks them to a codeload tarball and fetches that as one.
 pub(crate) fn classic_block_is_git(patterns: &[String], resolved: Option<&str>) -> bool {
     patterns.iter().any(|p| {
-        split_pattern(p).is_some_and(|(_, range)| {
+        split_classic_pattern(p).is_some_and(|(_, range)| {
             let range = match range.strip_prefix("npm:") {
-                Some(aliased) => split_pattern(aliased).map_or("", |(_, r)| r),
+                Some(aliased) => split_classic_pattern(aliased).map_or("", |(_, r)| r),
                 None => range,
             };
             yarn_classic_range_is_git(range)