pack: publish workspace: directory dependencies as the workspace's version

docs/pm/workspaces.mdx

@@ -90,6 +90,13 @@ A specific version takes precedence over the package's `package.json` version:
 "workspace:1.0.2" -> "1.0.2" // Even if current version is 1.0.1
 ```
 
+You can also reference a workspace package by the path of its directory. The path is relative to the `package.json` that declares the dependency. Bun publishes the version of the package in that directory. When the dependency name differs from the package name, Bun publishes an `npm:` alias:
+
+```
+"pkg-b": "workspace:../pkg-b" -> "pkg-b": "1.0.1"
+"b": "workspace:../pkg-b"     -> "b": "npm:pkg-b@1.0.1"
+```
+
 Workspaces have a few major benefits.
 
 - **Split code into logical parts.** If one package relies on another, add it as a dependency in `package.json`. If package `b` depends on `a`, `bun install` installs your local `packages/a` directory into `node_modules` instead of downloading it from the npm registry.

src/install/PackageManager/workspace_manifests.rs

@@ -3,9 +3,11 @@
 use bstr::BStr;
 use bun_collections::HashMap;
 use bun_core::{Global, Output};
+use bun_paths::{platform, resolve_path};
+use bun_resolver::fs::FileSystem;
 
 use crate::dependency::{Behavior, Tag as DependencyTag};
-use crate::lockfile::{Lockfile, Package};
+use crate::lockfile::{DependencySlice, Lockfile, Package};
 use crate::{Features, PackageNameHash};
 
 use super::PackageManager;
@@ -92,6 +94,8 @@
 /// and releases bump versions between that install and the publish.
 pub struct WorkspaceManifests {
     lockfile: Lockfile,
+    /// Has a `Behavior::WORKSPACE` entry per workspace: its name and root-relative directory.
+    root_dependencies: DependencySlice,
     root_package_json_path: Box<[u8]>,
 }
 
@@ -108,10 +112,53 @@
         }
         WorkspaceManifests {
             lockfile: scratch.lockfile,
+            root_dependencies: scratch.root.dependencies,
             root_package_json_path: root_package_json_path(),
         }
     }
 
+    /// Whether `name` is one of the workspaces (the root package is not one).
+    pub fn has_workspace(&self, name: &[u8]) -> bool {
+        let name_hash: PackageNameHash = bun_semver::string::Builder::string_hash(name);
+        self.lockfile.workspace_paths.contains(&name_hash)
+    }
+
+    /// The workspace `workspace:<path>` in `package_dir` links, per `Package::parse_dependency`.
+    pub fn workspace_name_at_path(&self, package_dir: &[u8], path: &[u8]) -> Option<&[u8]> {
+        // Joined as a path, `workspace:` alone would name `package_dir` itself.
+        if path.is_empty() {
+            return None;
+        }
+        let top_level_dir = FileSystem::get().top_level_dir();
+        let mut directory_buf = bun_paths::path_buffer_pool::get();
+        let directory = resolve_path::join_abs_string_buf_checked::<platform::Auto>(
+            top_level_dir,
+            &mut directory_buf[..],
+            &[package_dir, path],
+        )?;
+        let relative_directory: &[u8] = resolve_path::relative(top_level_dir, directory);
+        // The workspaces' directories are stored with `/` separators on every platform.
+        #[cfg(windows)]
+        let mut posix_buf = bun_paths::path_buffer_pool::get();
+        #[cfg(windows)]
+        let relative_directory: &[u8] = {
+            let len = relative_directory.len();
+            posix_buf[..len].copy_from_slice(relative_directory);
+            bun_paths::dangerously_convert_path_to_posix_in_place::<u8>(&mut posix_buf[..len]);
+            &posix_buf[..len]
+        };
+
+        let string_buf = self.lockfile.buffers.string_bytes.as_slice();
+        self.root_dependencies
+            .get(self.lockfile.buffers.dependencies.as_slice())
+            .iter()
+            .find(|dependency| {
+                dependency.behavior.is_workspace()
+                    && dependency.version.workspace().slice(string_buf) == relative_directory
+            })
+            .map(|dependency| dependency.name.slice(string_buf))
+    }
+
     /// The package.json whose `workspaces` and catalogs these are: the workspace root's when the
     /// package being packed is one of its workspaces, otherwise the package's own.
     pub fn root_package_json_path(&self) -> &[u8] {

src/runtime/cli/pack_command.rs

@@ -2131,7 +2131,8 @@
         // Loading added the other workspaces' package.json files to the cache `json` points into.
         json = read_package_json(manager_ptr, abs_package_json_path);
     }
-    let edited_package_json = edit_root_package_json(workspace_manifests.as_ref(), json)?;
+    let edited_package_json =
+        edit_root_package_json(workspace_manifests.as_ref(), abs_workspace_path, json)?;
 
     let root_dir: Dir = 'root_dir: {
         let mut path_buf = PathBuffer::uninit();
@@ -3197,8 +3198,8 @@
 enum Substitution<'a> {
     /// `workspace:^`, `workspace:~`, `workspace:*`: the workspace's current version behind that prefix.
     WorkspaceVersion { prefix: &'static str },
-    /// `workspace:1.2.3`, `workspace:1.x`, ...: the range as written.
-    WorkspaceRange(&'a [u8]),
+    /// `workspace:1.x` on a dependency that is a workspace, or a directory, `workspace:../core`.
+    WorkspaceRangeOrDirectory(&'a [u8]),
     /// `catalog:` / `catalog:<name>`: that catalog's entry for the dependency.
     Catalog { catalog_name: &'a [u8] },
 }
@@ -3210,18 +3211,14 @@
                 b"^" => Substitution::WorkspaceVersion { prefix: "^" },
                 b"~" => Substitution::WorkspaceVersion { prefix: "~" },
                 b"*" => Substitution::WorkspaceVersion { prefix: "" },
-                _ => Substitution::WorkspaceRange(range),
+                _ => Substitution::WorkspaceRangeOrDirectory(range),
             });
         }
         let catalog_name = strings::without_prefix_if_possible_comptime(spec, b"catalog:")?;
         Some(Substitution::Catalog {
             catalog_name: strings::trim(catalog_name, &strings::WHITESPACE_CHARS),
         })
     }
-
-    fn needs_workspace_manifests(&self) -> bool {
-        !matches!(self, Substitution::WorkspaceRange(_))
-    }
 }
 
 /// Section order is the order errors get reported in.
@@ -3257,15 +3254,52 @@
             .as_ref()
             .and_then(Expr::as_utf8_string_literal)
             .and_then(Substitution::for_spec)
-            .is_some_and(|substitution| substitution.needs_workspace_manifests());
+            .is_some();
     });
     needed
 }
 
+/// Directory first: `"pkg1": "workspace:../pkg1"` reads both ways; only a directory has a version.
+fn publish_spec_for_workspace_range_or_directory(
+    manifests: &WorkspaceManifests,
+    package_dir: &[u8],
+    dependency_name: &[u8],
+    spec: &[u8],
+) -> Result<Vec<u8>, String> {
+    let Some(workspace_name) = manifests.workspace_name_at_path(package_dir, spec) else {
+        // `workspace:<name>@<range>` installs workspace `<name>` under `dependency_name`.
+        let is_alias = strings::last_index_of_char(spec, b'@')
+            .is_some_and(|at| at > 0 && manifests.has_workspace(&spec[..at]));
+        if manifests.has_workspace(dependency_name) || is_alias {
+            return Ok(spec.to_vec());
+        }
+        return Err(format!(
+            "\"{}\" has no workspace named \"{}\" and no workspace in the directory \"{}\"",
+            bstr::BStr::new(manifests.root_package_json_path()),
+            bstr::BStr::new(dependency_name),
+            bstr::BStr::new(spec),
+        ));
+    };
+    let Some(version) = manifests.workspace_version(workspace_name) else {
+        return Err(format!(
+            "the package.json of workspace \"{}\" in the directory \"{}\" has no version",
+            bstr::BStr::new(workspace_name),
+            bstr::BStr::new(spec),
+        ));
+    };
+    Ok(if workspace_name == dependency_name {
+        format!("{version}").into_bytes()
+    } else {
+        // What pnpm publishes too: the alias installs the workspace's package under this name.
+        format!("npm:{}@{version}", bstr::BStr::new(workspace_name)).into_bytes()
+    })
+}
+
 /// Edits `json.root` in place (`bun publish` sends that tree to the registry) and returns it printed.
 /// `workspace_manifests` is `Some` whenever `needs_workspace_manifests(json.root)` is.
 fn edit_root_package_json(
     workspace_manifests: Option<&WorkspaceManifests>,
+    package_dir: &[u8],
     json: &mut WorkspacePackageJSONCache::MapEntry,
 ) -> Result<Box<[u8]>, AllocError> {
     let bump = pack_bump();
@@ -3303,7 +3337,6 @@
 
         // `E::EString::init` keeps a pointer to the bytes, so they go into the pack arena.
         let replacement: &[u8] = match substitution {
-            Substitution::WorkspaceRange(range) => bump.alloc_slice_copy(range),
             Substitution::WorkspaceVersion { prefix } => {
                 let Some(version) = manifests().workspace_version(dependency_name) else {
                     fail(
@@ -3317,6 +3350,17 @@
                 };
                 bump.alloc_slice_copy(format!("{prefix}{version}").as_bytes())
             }
+            Substitution::WorkspaceRangeOrDirectory(spec) => {
+                match publish_spec_for_workspace_range_or_directory(
+                    manifests(),
+                    package_dir,
+                    dependency_name,
+                    spec,
+                ) {
+                    Ok(published) => bump.alloc_slice_copy(&published),
+                    Err(why) => fail("workspace", format_args!("{why}")),
+                }
+            }
             Substitution::Catalog { catalog_name } => {
                 match manifests().catalog_version(catalog_name, dependency_name) {
                     Some(version) => bump.alloc_slice_copy(version),