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 core::fmt;
 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,10 @@ impl ScratchManifests {
 /// and releases bump versions between that install and the publish.
 pub struct WorkspaceManifests {
     lockfile: Lockfile,
+    /// The root package's dependencies. The root parse turns each entry of its `workspaces` into a
+    /// `Behavior::WORKSPACE` dependency named after the workspace whose `workspace` value is its
+    /// directory relative to the root.
+    root_dependencies: DependencySlice,
     root_package_json_path: Box<[u8]>,
 }
 
@@ -108,10 +114,60 @@ impl WorkspaceManifests {
         }
         WorkspaceManifests {
             lockfile: scratch.lockfile,
+            root_dependencies: scratch.root.dependencies,
             root_package_json_path: root_package_json_path(),
         }
     }
 
+    /// Whether one of the workspaces (the root package is not one) is named `name`. This is what
+    /// decides, in `Package::parse_dependency`, whether the text after `workspace:` in a dependency
+    /// of that name is a version range or a directory.
+    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 name of the workspace whose directory is `path` taken relative to `package_dir`, the
+    /// directory of the package.json declaring `workspace:<path>`. `Package::parse_dependency`
+    /// links such a dependency by computing the same root-relative directory and matching it
+    /// against the workspaces, so this resolves exactly what `bun install` linked. `None` when no
+    /// workspace is in that directory.
+    pub fn workspace_name_at_path(&self, package_dir: &[u8], path: &[u8]) -> Option<&[u8]> {
+        // `workspace:` with nothing after it is an empty range, not the declaring package's own
+        // directory.
+        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 @@ pub(crate) fn pack<const FOR_PUBLISH: bool>(
         // 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,11 @@ fn add_archive_entry(
 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]),
+    /// Anything else after `workspace:`. `bun install` reads it as a version range when the
+    /// dependency is itself one of the workspaces (`"pkg1": "workspace:1.x"`) and otherwise as the
+    /// directory of the workspace to link (`"c7": "workspace:../core"`), so which one it is takes
+    /// the manifests; see `publish_spec_for_workspace_range_or_directory`.
+    WorkspaceRangeOrDirectory(&'a [u8]),
     /// `catalog:` / `catalog:<name>`: that catalog's entry for the dependency.
     Catalog { catalog_name: &'a [u8] },
 }
@@ -3210,18 +3214,14 @@ impl<'a> Substitution<'a> {
                 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 +3257,57 @@ fn needs_workspace_manifests(package_json: Expr) -> bool {
             .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
 }
 
+/// What the tarball gets for `Substitution::WorkspaceRangeOrDirectory`, or why there is nothing to
+/// publish for it. The directory reading is tried first because `"pkg1": "workspace:../pkg1"`
+/// satisfies both readings and only the directory has a version to publish: that workspace's own,
+/// as an `npm:` alias when the dependency is declared under another name (the registry's way of
+/// installing a package under a different name, and what pnpm publishes for this spec). A range is
+/// copied as written; so is `workspace:<name>@<range>`, which installs the workspace `<name>` under
+/// the dependency's name (the installer, too, only reads it that way when `<name>` is a workspace).
+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 {
+        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 {
+        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.
+/// `workspace_manifests` is `Some` whenever `needs_workspace_manifests(json.root)` is. `package_dir`
+/// is the directory of `json`, which `workspace:<directory>` specs are relative to.
 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 +3345,6 @@ fn edit_root_package_json(
 
         // `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 +3358,17 @@ fn edit_root_package_json(
                 };
                 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),