diff --git a/docs/guides/install/from-npm-install-to-bun-install.mdx b/docs/guides/install/from-npm-install-to-bun-install.mdx
index 1fcf44967f03..7758e5b4d11e 100644
--- a/docs/guides/install/from-npm-install-to-bun-install.mdx
+++ b/docs/guides/install/from-npm-install-to-bun-install.mdx
@@ -82,6 +82,12 @@ bun --filter 'lib-*' my-script
 # npm run --workspace lib-foo --workspace lib-bar my-script
 ```
 
+`bun run` also takes npm's `-w` / `--workspace` flag, with a package name or a folder. Put the flag before the script name:
+
+```sh terminal icon="terminal"
+bun run --workspace lib-foo --workspace lib-bar my-script
+```
+
 ---
 
 ## Update dependencies
diff --git a/docs/pm/filter.mdx b/docs/pm/filter.mdx
index ec8a989f959a..d92b484ffc1f 100644
--- a/docs/pm/filter.mdx
+++ b/docs/pm/filter.mdx
@@ -142,7 +142,7 @@ bun run --filter foo myscript
 
 ### Parallel and sequential mode
 
-Combine `--filter` or `--workspaces` with `--parallel` or `--sequential` to run scripts across workspace packages with Foreman-style prefixed output:
+Combine `--filter`, `--workspace` or `--workspaces` with `--parallel` or `--sequential` to run scripts across workspace packages with Foreman-style prefixed output:
 
 ```bash terminal icon="terminal"
 # Run "build" in all matching packages concurrently
@@ -161,9 +161,9 @@ bun run --parallel --no-exit-on-error --filter '*' test
 bun run --parallel --filter '*' build lint
 ```
 
-Bun prefixes each line of output with the package and script name (`pkg-a:build | ...`). Without `--filter`/`--workspaces`, the prefix is only the script name (`build | ...`). When a package's `package.json` has no `name` field, Bun uses the relative path from the workspace root instead.
+Bun prefixes each line of output with the package and script name (`pkg-a:build | ...`). Without a flag that selects packages (`--filter`, `--workspace`, `--workspaces`), the prefix is only the script name (`build | ...`). When a package's `package.json` has no `name` field, Bun uses the relative path from the workspace root instead.
 
-Use `--if-present` with `--workspaces` to skip packages that don't have the requested script instead of erroring.
+Use `--if-present` with `--workspace` or `--workspaces` to skip packages that don't have the requested script instead of erroring.
 
 ### Dependency Order
 
diff --git a/docs/runtime/index.mdx b/docs/runtime/index.mdx
index fbf58dd8c34b..2aad5b8d79f0 100644
--- a/docs/runtime/index.mdx
+++ b/docs/runtime/index.mdx
@@ -162,6 +162,26 @@ executes `<script>` in both `bar` and `baz`, but not in `foo`.
 
 See [`--filter`](/pm/filter#running-scripts-with-filter).
 
+### npm's `--workspace`
+
+`bun run` also takes npm's `-w` / `--workspace <value>` flag. Bun matches the value against the workspace packages as npm does. The value is the name of a package, the path of its folder, or the path of a folder that holds packages:
+
+```bash terminal icon="terminal"
+# the package named "api" and the package in the folder ./api
+bun run --workspace api build
+
+# every workspace package directly inside ./packages
+bun run -w packages build
+```
+
+Put the flag before the script name, like `--filter`. npm's `npm run build -w api` is `bun run -w api build`. Bun passes the words after the script name to the script, so `bun run build -w api` gives `-w api` to the `build` script of the current package.
+
+- A name must match exactly, because the value is not a pattern. A package without a `name` is selected by its path.
+- With several `--workspace` flags, the packages run one after another, in the order of the flags.
+- If a selected package does not have the script, the run fails before a script starts. Pass `--if-present` to skip that package.
+- `--workspace` combines with `--filter` like one more positive pattern. `--workspaces` adds no packages to the ones that `--workspace` selects.
+- Bun finds the workspace root and its packages as it does for `--filter`.
+
 ## `bun run -` to pipe code from stdin
 
 `bun run -` reads JavaScript, TypeScript, TSX, or JSX from stdin and executes it without writing to a temporary file first.
diff --git a/docs/snippets/cli/run.mdx b/docs/snippets/cli/run.mdx
index 20372999dfe4..9dd8c1b222fa 100644
--- a/docs/snippets/cli/run.mdx
+++ b/docs/snippets/cli/run.mdx
@@ -36,6 +36,10 @@ bun run <file or script>
   Run a script in all workspace packages matching the pattern. Alias: <code>-F</code>
 </ParamField>
 
+<ParamField path="--workspace" type="string">
+  Run a script in the workspace packages with this name or in this folder, as in npm. Alias: <code>-w</code>
+</ParamField>
+
 <ParamField path="--workspaces" type="boolean">
   Run a script in all workspace packages (from the <code>workspaces</code> field in <code>package.json</code>)
 </ParamField>
diff --git a/src/clap/comptime.rs b/src/clap/comptime.rs
index 193dad5f5e82..d30ee0248e52 100644
--- a/src/clap/comptime.rs
+++ b/src/clap/comptime.rs
@@ -547,6 +547,7 @@ impl<Id> ComptimeClap<Id> {
             unknown_long_flags_are_positional: opt.unknown_long_flags_are_positional,
             unknown_long_flags_are_errors: opt.unknown_long_flags_are_errors,
             ignored_long_flags: opt.ignored_long_flags,
+            param_rules: opt.param_rules,
         };
 
         while let Some(arg) = stream.next()? {
diff --git a/src/clap/lib.rs b/src/clap/lib.rs
index e523cc9ad6f5..a2a32e73565f 100644
--- a/src/clap/lib.rs
+++ b/src/clap/lib.rs
@@ -388,6 +388,17 @@ pub struct ParseOptions<'a> {
     /// command.
     pub unknown_long_flags_are_errors: bool,
     pub ignored_long_flags: IgnoredLongFlags,
+    /// Rules of this parse for params of the table, each named by its long name without the dashes.
+    pub param_rules: &'static [(&'static [u8], ParamRule)],
+}
+
+/// How one command reads a param of a table that it shares with other commands.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum ParamRule {
+    /// The command does not have the param. Its flags are read like the flags of no param.
+    Absent,
+    /// The short flag takes no glued value: `-w client` and `-w=client` parse, `-wclient` fails.
+    SeparateValue,
 }
 
 /// Long flags, written without the dashes, that are skipped instead of failing the parse when
@@ -492,6 +503,7 @@ pub fn parse<Id: 'static>(
             unknown_long_flags_are_positional: opt.unknown_long_flags_are_positional,
             unknown_long_flags_are_errors: opt.unknown_long_flags_are_errors,
             ignored_long_flags: opt.ignored_long_flags,
+            param_rules: opt.param_rules,
         },
     )?;
     Ok(Args { clap })
@@ -515,6 +527,7 @@ pub fn parse_with_table<Id: 'static>(
             unknown_long_flags_are_positional: opt.unknown_long_flags_are_positional,
             unknown_long_flags_are_errors: opt.unknown_long_flags_are_errors,
             ignored_long_flags: opt.ignored_long_flags,
+            param_rules: opt.param_rules,
         },
     )?;
     Ok(Args { clap })
diff --git a/src/clap/streaming.rs b/src/clap/streaming.rs
index 159ede686d14..ec2f9c19e69b 100644
--- a/src/clap/streaming.rs
+++ b/src/clap/streaming.rs
@@ -66,6 +66,7 @@ pub struct StreamingClap<'p, 'a, Id, ArgIterator> {
     pub(crate) unknown_long_flags_are_positional: bool,
     pub(crate) unknown_long_flags_are_errors: bool,
     pub(crate) ignored_long_flags: clap::IgnoredLongFlags,
+    pub(crate) param_rules: &'static [(&'static [u8], clap::ParamRule)],
 }
 
 // ArgIterator is the
@@ -116,7 +117,7 @@ where
                 // Copy the slice ref so `&mut self` is free inside the loop.
                 let params = self.params;
                 for param in params {
-                    if !param.names.matches_long(name) {
+                    if !param.names.matches_long(name) || self.is_absent(param) {
                         continue;
                     }
 
@@ -254,7 +255,7 @@ where
             let Some(short) = param.names.short else {
                 continue;
             };
-            if short != arg[index] {
+            if short != arg[index] || self.is_absent(param) {
                 continue;
             }
 
@@ -306,6 +307,11 @@ where
                 }));
             }
 
+            if self.rule_of(param) == Some(clap::ParamRule::SeparateValue) {
+                let word = [b"-".as_slice(), arg].concat();
+                return Err(self.err(&word, None, None, ArgError::InvalidArgument));
+            }
+
             return Ok(Some(Arg {
                 param,
                 value: Some(&arg[next_index..]),
@@ -373,7 +379,7 @@ where
                 if !self
                     .params
                     .iter()
-                    .any(|param| param.names.matches_long(name))
+                    .any(|param| param.names.matches_long(name) && !self.is_absent(param))
                 {
                     return Ok(Some(ArgInfo {
                         arg: full_arg,
@@ -399,6 +405,15 @@ where
         }))
     }
 
+    fn rule_of(&self, param: &clap::Param<Id>) -> Option<clap::ParamRule> {
+        let long = param.names.long?;
+        (self.param_rules.iter()).find_map(|(name, rule)| (*name == long).then_some(*rule))
+    }
+
+    fn is_absent(&self, param: &clap::Param<Id>) -> bool {
+        self.rule_of(param) == Some(clap::ParamRule::Absent)
+    }
+
     fn err(&mut self, arg: &[u8], short: Option<u8>, long: Option<&[u8]>, e: ArgError) -> ArgError {
         if let Some(d) = self.diagnostic.as_deref_mut() {
             // `Diagnostic` owns
@@ -429,6 +444,7 @@ mod tests {
             unknown_long_flags_are_positional: false,
             unknown_long_flags_are_errors: false,
             ignored_long_flags: Default::default(),
+            param_rules: &[],
             params,
             iter: &mut iter,
             state: State::Normal,
@@ -465,6 +481,7 @@ mod tests {
             unknown_long_flags_are_positional: false,
             unknown_long_flags_are_errors: false,
             ignored_long_flags: Default::default(),
+            param_rules: &[],
             params,
             iter: &mut iter,
             state: State::Normal,
@@ -940,6 +957,7 @@ mod tests {
             unknown_long_flags_are_positional: true,
             unknown_long_flags_are_errors: false,
             ignored_long_flags: Default::default(),
+            param_rules: &[],
             params: &params,
             iter: &mut iter,
             state: State::Normal,
@@ -992,6 +1010,7 @@ mod tests {
             unknown_long_flags_are_positional: true,
             unknown_long_flags_are_errors: false,
             ignored_long_flags: Default::default(),
+            param_rules: &[],
             params: &params,
             iter: &mut iter,
             state: State::Normal,
@@ -1039,6 +1058,7 @@ mod tests {
                 unknown_long_flags_are_positional: false,
                 unknown_long_flags_are_errors: true,
                 ignored_long_flags: Default::default(),
+                param_rules: &[],
                 params: &params,
                 iter: &mut iter,
                 state: State::Normal,
@@ -1061,4 +1081,77 @@ mod tests {
         assert_eq!(parse(&[b"x", b"--q", b"y"]), Some(b"q".to_vec()));
         assert_eq!(parse(&[b"--q=1"]), Some(b"q".to_vec()));
     }
+
+    #[test]
+    fn param_rules() {
+        let params: [clap::Param<u8>; 2] = [
+            clap::Param {
+                id: 0,
+                names: clap::Names {
+                    short: Some(b'c'),
+                    long: Some(b"cc"),
+                    ..Default::default()
+                },
+                takes_value: clap::Values::One,
+                ..Default::default()
+            },
+            clap::Param {
+                id: 1,
+                takes_value: clap::Values::Many,
+                ..Default::default()
+            },
+        ];
+        // The values that the parse read, or the word that it refused.
+        let parse = |rule: clap::ParamRule, args: &[&[u8]]| {
+            let mut diag = clap::Diagnostic::default();
+            let mut iter = args::SliceIterator { remain: args };
+            let mut c = StreamingClap::<u8, args::SliceIterator> {
+                short_aliases: &[],
+                unknown_long_flags_are_positional: false,
+                unknown_long_flags_are_errors: false,
+                ignored_long_flags: Default::default(),
+                param_rules: match rule {
+                    clap::ParamRule::Absent => &[(b"cc", clap::ParamRule::Absent)],
+                    clap::ParamRule::SeparateValue => &[(b"cc", clap::ParamRule::SeparateValue)],
+                },
+                params: &params,
+                iter: &mut iter,
+                state: State::Normal,
+                positional: None,
+                diagnostic: Some(&mut diag),
+            };
+            let mut seen: Vec<(u8, Vec<u8>)> = Vec::new();
+            loop {
+                match c.next() {
+                    Ok(Some(arg)) => seen.push((arg.param.id, arg.value.unwrap().to_vec())),
+                    Ok(None) => return Ok(seen),
+                    Err(err) => {
+                        assert_eq!(err, ArgError::InvalidArgument);
+                        break;
+                    }
+                }
+            }
+            Err(match diag.short {
+                Some(short) => vec![b'-', short],
+                None => diag.arg,
+            })
+        };
+
+        let separate = clap::ParamRule::SeparateValue;
+        assert_eq!(
+            parse(separate, &[b"-c", b"x"]),
+            Ok(vec![(0, b"x".to_vec())])
+        );
+        assert_eq!(parse(separate, &[b"-c=x"]), Ok(vec![(0, b"x".to_vec())]));
+        assert_eq!(parse(separate, &[b"--cc=x"]), Ok(vec![(0, b"x".to_vec())]));
+        assert_eq!(parse(separate, &[b"-cx"]), Err(b"-cx".to_vec()));
+
+        // An absent param is like no param: the short flag is refused, the long flag is skipped.
+        let absent = clap::ParamRule::Absent;
+        assert_eq!(parse(absent, &[b"-c", b"x"]), Err(b"-c".to_vec()));
+        assert_eq!(
+            parse(absent, &[b"--cc", b"x"]),
+            Ok(vec![(1, b"x".to_vec())])
+        );
+    }
 }
diff --git a/src/install/PackageManager/workspace_selection.rs b/src/install/PackageManager/workspace_selection.rs
index b44433dbded5..5189723b8e72 100644
--- a/src/install/PackageManager/workspace_selection.rs
+++ b/src/install/PackageManager/workspace_selection.rs
@@ -61,7 +61,8 @@ struct Selector {
     base: Base,
 }
 
-fn strip_negations(raw: &[u8]) -> (&[u8], bool) {
+/// The pattern without its leading `!`s, and whether they negate it.
+pub fn strip_negations(raw: &[u8]) -> (&[u8], bool) {
     let mut remain = raw;
     let mut negated = false;
     while let Some(rest) = remain.strip_prefix(b"!") {
diff --git a/src/install/lifecycle_script_runner.rs b/src/install/lifecycle_script_runner.rs
index 8f92cfb730f1..ef81a62ca8cc 100644
--- a/src/install/lifecycle_script_runner.rs
+++ b/src/install/lifecycle_script_runner.rs
@@ -222,7 +222,12 @@ pub fn replace_package_manager_run(
             }
             b'p' => {
                 if delimiter > 0 {
-                    if strings::has_prefix_comptime(&script[start..], b"pnpm run ") {
+                    // pnpm's `-w` is `--workspace-root`. `bun run` has npm's `-w`, which takes a value.
+                    if strings::has_prefix_comptime(&script[start..], b"pnpm run ")
+                        && !strings::tokenize_any(&script[start + b"pnpm run ".len()..], b" \t")
+                            .take_while(|word| word[0] == b'-')
+                            .any(|word| word == b"-w")
+                    {
                         append_bun_run(copy_script);
                         copy_script.push(b' ');
                         entry_i += b"pnpm run ".len();
@@ -269,8 +274,9 @@ fn append_npm_run_in_workspaces(out: &mut Vec<u8>, args: &[u8]) -> usize {
     let mut selects_workspaces = false;
     let mut tokens = strings::tokenize_any(command, b" \t");
     while let Some(token) = tokens.next() {
-        let workspace = match token {
-            b"-w" | b"--workspace" => tokens.next(),
+        // The `=` stays: a shell expands `-w={a,b}` to two flags, and `-w {a,b}` to a value and a script name.
+        let (workspace, separator): (Option<&[u8]>, &[u8]) = match token {
+            b"-w" | b"--workspace" => (tokens.next(), b" "),
             b"--workspaces" | b"--ws" => {
                 selects_workspaces = true;
                 flags.extend_from_slice(b" --workspaces");
@@ -291,7 +297,7 @@ fn append_npm_run_in_workspaces(out: &mut Vec<u8>, args: &[u8]) -> usize {
                 .strip_prefix(b"--workspace=")
                 .or_else(|| token.strip_prefix(b"-w="))
             {
-                Some(workspace) => Some(workspace),
+                Some(workspace) => (Some(workspace), b"="),
                 None => {
                     rest.push(b' ');
                     rest.extend_from_slice(token);
@@ -308,12 +314,9 @@ fn append_npm_run_in_workspaces(out: &mut Vec<u8>, args: &[u8]) -> usize {
             return 0;
         };
         selects_workspaces = true;
-        flags.extend_from_slice(b" --filter=");
-        // npm also accepts the workspace's folder. `--filter` tells a path from a name by the
-        // leading dot.
-        if strings::contains_char(workspace, b'/') && !matches!(workspace[0], b'@' | b'.' | b'/') {
-            flags.extend_from_slice(b"./");
-        }
+        // The short flag: a `bun` in `PATH` from before the flag refuses `-w`, but skips `--workspace` and runs this package's script.
+        flags.extend_from_slice(b" -w");
+        flags.extend_from_slice(separator);
         flags.extend_from_slice(workspace);
     }
 
diff --git a/src/options_types/context.rs b/src/options_types/context.rs
index d7dd2d282fa9..5b90f0de3d07 100644
--- a/src/options_types/context.rs
+++ b/src/options_types/context.rs
@@ -35,7 +35,7 @@ pub struct ContextData {
     pub bundler_options: BundlerOptions,
     pub runtime_options: RuntimeOptions,
 
-    pub filters: Vec<Box<[u8]>>,
+    pub filters: Vec<PackageFilter>,
     pub workspaces: bool,
     pub if_present: bool,
     pub parallel: bool,
@@ -46,6 +46,23 @@ pub struct ContextData {
     pub has_loaded_global_config: bool,
 }
 
+/// Which workspace packages `bun run` runs a script in.
+pub enum PackageFilter {
+    /// `--filter <pattern>`
+    Pattern(Box<[u8]>),
+    /// `--workspace <value>`: a package's name, its folder or the parent of its folder, as in npm.
+    Workspace(Box<[u8]>),
+}
+
+impl PackageFilter {
+    /// The value as it was given.
+    pub fn text(&self) -> &[u8] {
+        match self {
+            PackageFilter::Pattern(text) | PackageFilter::Workspace(text) => text,
+        }
+    }
+}
+
 impl Default for ContextData {
     // ── Startup .text page-fault reduction ───────────────────────────────
     // `--version` perf showed `ContextData::default` (1 638 B) plus its
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index d2a105468ec6..fbddcf26468f 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -17,7 +17,9 @@ use bun_core::{self, FeatureFlags, Global, Output, env_var};
 use bun_jsc::RegularExpression;
 use bun_jsc::regular_expression::Flags as RegexFlags;
 use bun_options_types::code_coverage_options::Reporters as CoverageReporters;
-use bun_options_types::context::{Debugger, DebuggerEnable, HotReload, MacroOptions, Shard};
+use bun_options_types::context::{
+    Debugger, DebuggerEnable, HotReload, MacroOptions, PackageFilter, Shard,
+};
 use bun_options_types::schema::api;
 use bun_paths::platform;
 use bun_paths::resolve_path;
@@ -369,6 +371,9 @@ const RUN_ONLY_PARAMS: &[ParamType] = concat_params!(
         parse_param!(
             "--elide-lines <NUMBER>            Number of lines of script output shown when using --filter (default: 0, show all lines)"
         ),
+        parse_param!(
+            "-w, --workspace <STR>...          Run a script in a workspace package, given by its name or its folder as in npm"
+        ),
     ],
     AUTO_OR_RUN_PARAMS,
 );
@@ -834,6 +839,13 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
                 CommandTag::AutoCommand | CommandTag::RunAsNodeCommand => NODE_SHORT_ALIASES,
                 _ => &[],
             },
+            param_rules: match cmd {
+                // npm reads `-ws` as `--workspaces`, so `bun run` does not read it as `-w s`.
+                CommandTag::RunCommand => &[(b"workspace", clap::ParamRule::SeparateValue)],
+                // bun as `node` shares `RUN_TABLE` and has no `--workspace`.
+                CommandTag::RunAsNodeCommand => &[(b"workspace", clap::ParamRule::Absent)],
+                _ => &[],
+            },
             ..Default::default()
         },
     ) {
@@ -922,7 +934,9 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
     }
 
     if matches!(cmd, CommandTag::RunCommand | CommandTag::AutoCommand) {
-        ctx.filters = slice_to_owned(args.options(b"--filter"));
+        ctx.filters = (args.options(b"--filter").iter())
+            .map(|pattern| PackageFilter::Pattern((*pattern).into()))
+            .collect();
         ctx.workspaces = args.flag(b"--workspaces");
         ctx.if_present = args.flag(b"--if-present");
         ctx.parallel = args.flag(b"--parallel");
@@ -949,6 +963,13 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
         }
     }
 
+    // Only `RUN_TABLE` has `--workspace`. Stays above the load of bunfig.toml, which reads `[run]` for a run that selects packages.
+    if cmd == CommandTag::RunCommand {
+        for value in args.options(b"--workspace") {
+            ctx.filters.push(PackageFilter::Workspace((*value).into()));
+        }
+    }
+
     if cmd == CommandTag::TestCommand {
         parse_test_command_options(&args, ctx);
     }
diff --git a/src/runtime/cli/filter_arg.rs b/src/runtime/cli/filter_arg.rs
index caa6e2502034..86993051a96c 100644
--- a/src/runtime/cli/filter_arg.rs
+++ b/src/runtime/cli/filter_arg.rs
@@ -2,6 +2,7 @@ use core::ptr::NonNull;
 
 use bstr::BStr;
 use bun_ast::{self, ExprData, Log};
+use bun_collections::index_sort;
 use bun_core::Global;
 use bun_core::Output;
 use bun_core::strings;
@@ -9,6 +10,7 @@ use bun_glob as glob;
 use bun_install::package_manager::workspace_selection::{
     self, Candidate, NegatedWorkspaces, RootSelection, WorkspaceGraph,
 };
+use bun_options_types::context::PackageFilter;
 use bun_parsers::json;
 use bun_paths::path_buffer_pool;
 use bun_paths::{PathBuffer, platform, resolve_path};
@@ -152,24 +154,38 @@ pub(crate) struct WorkspacePackage {
     pub(crate) package_json_path: Box<[u8]>,
     pub(crate) dir: Box<[u8]>,
     pub(crate) json: bun_resolver::PackageJSON,
+    /// The first `--workspace` value that selects the package, if one does.
+    workspace_value: Option<usize>,
+    /// The entry of `workspaces` that the package comes from.
+    entry: usize,
 }
 
 pub(crate) struct SelectedPackages {
     pub(crate) root_dir: Box<[u8]>,
     pub(crate) packages: Vec<WorkspacePackage>,
+    /// Only `--workspace` values select: as in npm, the packages are in the order of the values and run one after another.
+    pub(crate) in_given_order: bool,
 }
 
-/// Discovers the workspace packages under `cwd` and returns the ones `--filter` / `--workspaces` select, in discovery order.
+/// Discovers the workspace packages under `cwd` and returns the ones `--filter` / `--workspace` / `--workspaces` select, in discovery order unless `SelectedPackages::in_given_order`.
 pub(crate) fn select_packages(
     ctx: &Command::ContextData,
     resolver: &mut bun_resolver::Resolver<'_>,
     cwd: &[u8],
 ) -> Result<SelectedPackages, crate::Error> {
-    let patterns: Vec<&[u8]> = if ctx.workspaces {
-        vec![b"*".as_slice()]
-    } else {
-        ctx.filters.iter().map(|f| &f[..]).collect()
-    };
+    let mut patterns: Vec<&[u8]> = Vec::new();
+    let mut workspaces: Vec<&[u8]> = Vec::new();
+    for filter in &ctx.filters {
+        match filter {
+            PackageFilter::Pattern(pattern) => patterns.push(pattern),
+            PackageFilter::Workspace(workspace) => workspaces.push(workspace),
+        }
+    }
+    // As in npm, `--workspaces` adds nothing to what `--workspace` names.
+    let all_workspaces = ctx.workspaces && workspaces.is_empty();
+    if all_workspaces {
+        patterns = vec![b"*".as_slice()];
+    }
 
     let mut glob_patterns: Vec<Box<[u8]>> = Vec::new();
     let mut negated = NegatedWorkspaces::default();
@@ -190,7 +206,7 @@ pub(crate) fn select_packages(
         let dir = strings::without_trailing_slash(resolve_path::dirname::<platform::Auto>(
             &package_json_path,
         ));
-        if ctx.workspaces && dir == &*root_dir {
+        if all_workspaces && dir == &*root_dir {
             continue;
         }
         let Some(json) = bun_resolver::PackageJSON::parse::<{ IncludeDependencies::Main }>(
@@ -210,6 +226,8 @@ pub(crate) fn select_packages(
             dir: dir.into(),
             package_json_path,
             json,
+            workspace_value: None,
+            entry: iter.pattern_idx,
         });
     }
 
@@ -247,20 +265,55 @@ pub(crate) fn select_packages(
             })
         });
 
-    let selection = workspace_selection::select(
-        &patterns,
-        cwd,
-        &candidates,
-        graph.as_ref(),
-        RootSelection::Implicit,
-    );
-    let packages: Vec<WorkspacePackage> = discovered
+    // `select` reads a list of only `!` patterns as every package, so next to a `--workspace` value they are asked on their own.
+    let mut excluded_patterns: Vec<&[u8]> = Vec::new();
+    if !workspaces.is_empty() {
+        let all = core::mem::take(&mut patterns);
+        for (pattern, is_negated) in all.into_iter().map(workspace_selection::strip_negations) {
+            if is_negated {
+                excluded_patterns.push(pattern);
+            } else {
+                patterns.push(pattern);
+            }
+        }
+    }
+    let select = |patterns: &[&[u8]]| {
+        (!patterns.is_empty()).then(|| {
+            workspace_selection::select(
+                patterns,
+                cwd,
+                &candidates,
+                graph.as_ref(),
+                RootSelection::Implicit,
+            )
+        })
+    };
+    let (included, excluded) = (select(&patterns), select(&excluded_patterns));
+    let (workspace_values, unmatched_workspaces) =
+        select_npm_workspaces(&workspaces, cwd, &root_dir, &candidates);
+
+    let mut packages: Vec<WorkspacePackage> = discovered
         .into_iter()
         .enumerate()
-        .filter(|&(i, _)| selection.selected.is_set(i))
-        .map(|(_, p)| p)
+        .filter_map(|(i, mut package)| {
+            package.workspace_value = workspace_values.get(i).copied().flatten();
+            let is_selected = package.workspace_value.is_some()
+                || included.as_ref().is_some_and(|it| it.selected.is_set(i));
+            let is_excluded = excluded.as_ref().is_some_and(|it| it.selected.is_set(i));
+            (is_selected && !is_excluded).then_some(package)
+        })
         .collect();
     if packages.is_empty() {
+        // npm fails here with `--if-present` too.
+        if !workspaces.is_empty() {
+            let filters: Vec<&[u8]> = (ctx.filters.iter())
+                .filter(|filter| matches!(filter, PackageFilter::Pattern(_)))
+                .map(PackageFilter::text)
+                .collect();
+            let message = unmatched_workspaces_message(&workspaces, &filters);
+            Output::err_generic("{}", (BStr::new(&message),));
+            Global::exit(1);
+        }
         if ctx.if_present {
             Global::exit(0);
         }
@@ -270,8 +323,118 @@ pub(crate) fn select_packages(
         }
         workspace_selection::error_unmatched(&patterns);
     }
-    workspace_selection::warn_unmatched(&patterns, &selection.unmatched_patterns);
-    Ok(SelectedPackages { root_dir, packages })
+    if let Some(included) = &included {
+        workspace_selection::warn_unmatched(&patterns, &included.unmatched_patterns);
+    }
+    if !unmatched_workspaces.is_empty() {
+        let unmatched: Vec<&[u8]> = unmatched_workspaces
+            .iter()
+            .map(|&i| workspaces[i])
+            .collect();
+        bun_core::warn!(
+            "{}",
+            BStr::new(&unmatched_workspaces_message(&unmatched, &[]))
+        );
+    }
+
+    // npm runs in the order of the values, and for one value in the order of `workspaces`.
+    let in_given_order = !workspaces.is_empty() && patterns.is_empty();
+    if in_given_order {
+        index_sort::sort_slice_by(&mut packages, |a, b| {
+            (a.workspace_value, a.entry, &a.dir).cmp(&(b.workspace_value, b.entry, &b.dir))
+        });
+    }
+    Ok(SelectedPackages {
+        root_dir,
+        packages,
+        in_given_order,
+    })
+}
+
+/// `No workspace packages matched --workspace "a", "b"`, with ` or --filter "c"` for `patterns`.
+fn unmatched_workspaces_message(workspaces: &[&[u8]], patterns: &[&[u8]]) -> Vec<u8> {
+    let mut out = b"No workspace packages matched --workspace ".to_vec();
+    out.extend_from_slice(&workspace_selection::quote_patterns(workspaces));
+    if !patterns.is_empty() {
+        out.extend_from_slice(b" or --filter ");
+        out.extend_from_slice(&workspace_selection::quote_patterns(patterns));
+    }
+    out
+}
+
+/// The four tests of npm 11's `lib/utils/get-workspaces.js`. Returns the first value that selects each candidate, and the values that select nothing.
+fn select_npm_workspaces(
+    values: &[&[u8]],
+    cwd: &[u8],
+    root_dir: &[u8],
+    candidates: &[Candidate<'_>],
+) -> (Vec<Option<usize>>, Vec<usize>) {
+    if values.is_empty() {
+        return (Vec::new(), Vec::new());
+    }
+    let (mut buf, mut joined) = (path_buffer_pool::get(), path_buffer_pool::get());
+    // The form of `Candidate::abs_posix_dir`.
+    let mut posix = |dir: &[u8]| -> Box<[u8]> {
+        strings::without_trailing_slash(resolve_path::join_abs_string_buf::<platform::Posix>(
+            dir,
+            &mut buf.0,
+            &[b".".as_slice()],
+        ))
+        .into()
+    };
+    let (from, root) = (posix(cwd), posix(root_dir));
+    let relative = resolve_path::relative_platform::<platform::Posix, true>;
+    // `./` and the directory as the cwd sees it. npm compares with the `./` when the value has one.
+    let from_cwd: Vec<Vec<u8>> = candidates
+        .iter()
+        .map(|c| [b"./".as_slice(), relative(&from, c.abs_posix_dir)].concat())
+        .collect();
+    let children_of = |folder: &[u8]| {
+        let pattern = [folder, b"/*".as_slice()].concat();
+        let shape = glob::matcher::Shape::of(&pattern);
+        (pattern, shape)
+    };
+
+    let mut first_values: Vec<Option<usize>> = vec![None; candidates.len()];
+    let mut unmatched: Vec<usize> = Vec::new();
+    for (at, &value) in values.iter().enumerate() {
+        let mut path = value.to_vec();
+        resolve_path::platform_to_posix_in_place::<u8>(&mut path);
+        // The join of the platform reads a drive letter.
+        let dir = resolve_path::join_abs_string_buf_checked::<platform::Auto>(
+            cwd,
+            &mut joined.0,
+            &[value],
+        )
+        .map(&mut posix);
+        let dir = dir.as_deref();
+        // The packages in the folder, which npm writes as a path from the root and as it was given.
+        let in_folder = [
+            dir.map(|dir| children_of(relative(&root, dir))),
+            Some(children_of(strings::without_trailing_slash(&path))),
+        ];
+
+        let mut selects = false;
+        for (i, c) in candidates.iter().enumerate() {
+            let from_cwd = &from_cwd[i][if path.starts_with(b"./") { 0 } else { 2 }..];
+            // `Dots::Hide` is minimatch's `dot: false`, which npm matches with.
+            let is_in_folder = |(pattern, shape): &(Vec<u8>, glob::matcher::Shape)| {
+                let hide = glob::Dots::Hide;
+                glob::matcher::match_prepared::<false>(pattern, shape, from_cwd, hide).matches()
+            };
+            if (!c.name.is_empty() && c.name == value)
+                || dir == Some(c.abs_posix_dir)
+                || in_folder.iter().flatten().any(is_in_folder)
+            {
+                first_values[i].get_or_insert(at);
+                selects = true;
+            }
+        }
+        if !selects {
+            unmatched.push(at);
+        }
+    }
+    (first_values, unmatched)
 }
 
 impl WorkspacePackage {
@@ -288,6 +451,37 @@ impl WorkspacePackage {
 }
 
 impl SelectedPackages {
+    /// As in npm, a package that `--workspace` selects must have the scripts, unless `--if-present` is set. A name with a `*` is a pattern and is not asked for.
+    pub(crate) fn require_scripts(&self, ctx: &Command::ContextData, names: &[&[u8]]) {
+        if ctx.if_present {
+            return;
+        }
+        let mut is_missing = false;
+        for package in &self.packages {
+            if package.workspace_value.is_none() {
+                continue;
+            }
+            for name in names {
+                if strings::contains_char(name, b'*')
+                    || (package.json.scripts.as_ref()).is_some_and(|it| it.get(name).is_some())
+                {
+                    continue;
+                }
+                Output::err_generic(
+                    "Script \"{}\" not found in package \"{}\"",
+                    (
+                        BStr::new(name),
+                        BStr::new(&package.display_name(&self.root_dir)),
+                    ),
+                );
+                is_missing = true;
+            }
+        }
+        if is_missing {
+            Global::exit(1);
+        }
+    }
+
     /// `error: Script "x" not found in package "a"` / `... in 3 packages matching "a*"` /
     /// `... in 3 workspace packages`, then exit 1. `scripts` is already quoted.
     pub(crate) fn error_script_not_found(&self, ctx: &Command::ContextData, scripts: &[u8]) -> ! {
@@ -306,7 +500,7 @@ impl SelectedPackages {
                 (BStr::new(scripts), n),
             );
         } else {
-            let patterns: Vec<&[u8]> = ctx.filters.iter().map(|f| &**f).collect();
+            let patterns: Vec<&[u8]> = ctx.filters.iter().map(PackageFilter::text).collect();
             Output::err_generic(
                 "Script {} not found in {} packages matching {}",
                 (
diff --git a/src/runtime/cli/filter_run.rs b/src/runtime/cli/filter_run.rs
index 5ad644a57410..4e1e1664852f 100644
--- a/src/runtime/cli/filter_run.rs
+++ b/src/runtime/cli/filter_run.rs
@@ -861,6 +861,7 @@ pub(crate) fn run_scripts_with_filter(
         &mut this_transpiler.resolver,
         fsinstance.top_level_dir(),
     )?;
+    selected.require_scripts(&*ctx, &[script_name]);
 
     let mut scripts: Vec<ScriptConfig> = Vec::new();
     for package in &selected.packages {
@@ -1071,6 +1072,10 @@ pub(crate) fn run_scripts_with_filter(
     }
     // compute dependencies (TODO: maybe we should do this only in a workspace?)
     for handle in state.handles.iter_mut() {
+        // The order of `--workspace` values decides, not the dependencies.
+        if selected.in_given_order {
+            break;
+        }
         let config = handle.config;
         for name in &config.deps {
             // is it a workspace dependency?
@@ -1103,7 +1108,9 @@ pub(crate) fn run_scripts_with_filter(
     // set up dependencies between pre/post scripts
     // this is done after the cycle check because we don't want these to be removed if there is a cycle
     for i in 0..state.handles.len() - 1 {
-        if state.handles[i].config.package_name == state.handles[i + 1].config.package_name {
+        if selected.in_given_order
+            || state.handles[i].config.package_name == state.handles[i + 1].config.package_name
+        {
             let next_ptr: *mut ProcessHandle = &raw mut state.handles[i + 1];
             state.handles[i].dependents.push(next_ptr);
             state.handles[i + 1].remaining_dependencies += 1;
diff --git a/src/runtime/cli/multi_run.rs b/src/runtime/cli/multi_run.rs
index b0590346f1de..f80ab1a320e2 100644
--- a/src/runtime/cli/multi_run.rs
+++ b/src/runtime/cli/multi_run.rs
@@ -933,6 +933,8 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
     if !ctx.filters.is_empty() || ctx.workspaces {
         // Workspace-aware mode: iterate over matching workspace packages
         let selected = FilterArg::select_packages(&*ctx, &mut this_transpiler.resolver, cwd)?;
+        let names: Vec<&[u8]> = script_names.iter().map(|n| &**n).collect();
+        selected.require_scripts(&*ctx, &names);
         let resolve_root: &[u8] = &selected.root_dir;
 
         // Phase 1: collect packages; `scripts` is deep-copied so MatchedPackage sorts independently of `selected`.
@@ -974,13 +976,15 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
         }
 
         // Phase 2: Sort by package name, then by path as tiebreaker for deterministic ordering
-        index_sort::sort_slice_by(&mut matched_packages, |a, b| {
-            let name_order = a.name.cmp(&b.name);
-            if name_order != core::cmp::Ordering::Equal {
-                return name_order;
-            }
-            a.dirpath.cmp(&b.dirpath)
-        });
+        if !selected.in_given_order {
+            index_sort::sort_slice_by(&mut matched_packages, |a, b| {
+                let name_order = a.name.cmp(&b.name);
+                if name_order != core::cmp::Ordering::Equal {
+                    return name_order;
+                }
+                a.dirpath.cmp(&b.dirpath)
+            });
+        }
 
         // Phase 3: Build configs from sorted packages
         for pkg in &matched_packages {
@@ -1032,7 +1036,6 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
             if ctx.if_present {
                 Global::exit(0);
             }
-            let names: Vec<&[u8]> = script_names.iter().map(|n| &**n).collect();
             selected.error_script_not_found(ctx, &workspace_selection::quote_patterns(&names));
         }
     } else {
diff --git a/test/cli/install/bun-run.test.ts b/test/cli/install/bun-run.test.ts
index 1c8918227511..1fe1db6b6af9 100644
--- a/test/cli/install/bun-run.test.ts
+++ b/test/cli/install/bun-run.test.ts
@@ -657,6 +657,8 @@ describe.concurrent("bun run", () => {
     ["npm run", "run"],
     ["npx", "x"],
     ["pnpm run", "run"],
+    // pnpm's `-w` is `--workspace-root`, which `bun run` does not have.
+    ["pnpm run -w", "passthrough"],
     ["pnpm dlx", "x"],
     ["pnpx", "x"],
   ];
@@ -701,19 +703,27 @@ describe.concurrent("bun run", () => {
 
   // https://github.com/oven-sh/bun/issues/33796
   describe("npm workspace flags in scripts", () => {
-    // `start` is the script under test. Only apps/app has `hello`, only the root has `greet`.
-    async function runStart(start: string) {
+    // `start` is the script under test. Only apps/app has `hello`, only the root has `greet`, and
+    // no package has the name of the folder `client`.
+    async function runStart(start: string, cmd = ["run", "start"], script = "start") {
       const dir = tempDir("npm-workspace-flags", {
         "package.json": JSON.stringify({
           private: true,
-          workspaces: ["apps/*"],
-          scripts: { start, greet: "echo greet-done" },
+          workspaces: ["apps/*", "client"],
+          scripts: { [script]: start, greet: "echo greet-done" },
+        }),
+        "apps/app/package.json": JSON.stringify({
+          name: "app",
+          scripts: { hello: "echo workspace-ok", start: "cd ../.. && npm run build -w client" },
         }),
-        "apps/app/package.json": JSON.stringify({ name: "app", scripts: { hello: "echo workspace-ok" } }),
         "apps/scoped/package.json": JSON.stringify({ name: "@apps/scoped", scripts: { scoped: "echo scoped-ok" } }),
+        "client/package.json": JSON.stringify({
+          name: "@scope/web",
+          scripts: { build: "echo client-ok", hello: "echo client-hello" },
+        }),
       });
       await using proc = Bun.spawn({
-        cmd: [bunExe(), "run", "start"],
+        cmd: [bunExe(), ...cmd],
         cwd: String(dir),
         env: bunEnv,
         stdout: "pipe",
@@ -726,19 +736,21 @@ describe.concurrent("bun run", () => {
     }
 
     it.each([
-      ["npm run hello -w app", " run --filter=app hello\n", "workspace-ok"],
-      ["npm run -w app hello", " run --filter=app hello\n", "workspace-ok"],
-      ["npm run hello --workspace app", " run --filter=app hello\n", "workspace-ok"],
-      ["npm run hello --workspace=app", " run --filter=app hello\n", "workspace-ok"],
-      ["npm run hello -w=app", " run --filter=app hello\n", "workspace-ok"],
-      ["npm run hello -w apps/app", " run --filter=./apps/app hello\n", "workspace-ok"],
-      ["npm run hello -w ./apps/app", " run --filter=./apps/app hello\n", "workspace-ok"],
-      ["npm run hello --workspace=apps/app", " run --filter=./apps/app hello\n", "workspace-ok"],
-      ["npm run scoped -w @apps/scoped", " run --filter=@apps/scoped scoped\n", "scoped-ok"],
+      ["npm run hello -w app", " run -w app hello\n", "workspace-ok"],
+      ["npm run -w app hello", " run -w app hello\n", "workspace-ok"],
+      ["npm run hello --workspace app", " run -w app hello\n", "workspace-ok"],
+      ["npm run hello --workspace=app", " run -w=app hello\n", "workspace-ok"],
+      ["npm run hello -w=app", " run -w=app hello\n", "workspace-ok"],
+      ["npm run hello -w apps/app", " run -w apps/app hello\n", "workspace-ok"],
+      ["npm run hello -w ./apps/app", " run -w ./apps/app hello\n", "workspace-ok"],
+      ["npm run hello --workspace=apps/app", " run -w=apps/app hello\n", "workspace-ok"],
+      ["npm run scoped -w @apps/scoped", " run -w @apps/scoped scoped\n", "scoped-ok"],
+      ["npm run build -w client", " run -w client build\n", "client-ok"],
+      ["npm run hello -w apps --if-present", " run -w apps --if-present hello\n", "workspace-ok"],
       ["npm run hello --ws --if-present", " run --workspaces --if-present hello\n", "workspace-ok"],
       ["npm run hello --workspaces --if-present", " run --workspaces --if-present hello\n", "workspace-ok"],
       ["echo chained && npm run hello --if-present --ws", " run --if-present --workspaces hello\n", "workspace-ok"],
-      ["npm run hello -w app && echo chained", " run --filter=app hello && echo chained\n", "chained"],
+      ["npm run hello -w app && echo chained", " run -w app hello && echo chained\n", "chained"],
     ])("%s runs the script of the workspace", async (start, rewritten, output) => {
       const { dir, stdout, stderr, exitCode } = await runStart(start);
       using _ = dir;
@@ -759,7 +771,8 @@ describe.concurrent("bun run", () => {
     ])("%s still runs the root's script", async start => {
       const { dir, stdout, stderr, exitCode } = await runStart(start);
       using _ = dir;
-      expect(stderr).not.toContain("--filter");
+      // A flag that was moved stands between `run` and the name.
+      expect(stderr).toContain(" run greet");
       expect(stdout).toContain("greet-done");
       expect(exitCode).toBe(0);
     });
@@ -767,7 +780,7 @@ describe.concurrent("bun run", () => {
     it("doesn't change a redirect that's attached to the workspace name", async () => {
       const { dir, stderr, exitCode } = await runStart("npm run greet -w app>out.txt");
       using _ = dir;
-      expect(stderr).not.toContain("--filter");
+      expect(stderr).toContain(" run greet");
       expect(await Bun.file(join(String(dir), "out.txt")).text()).toContain("greet-done");
       expect(exitCode).toBe(0);
     });
@@ -775,8 +788,32 @@ describe.concurrent("bun run", () => {
     it.skipIf(isWindows)("doesn't change an `npm run` that's only quoted text", async () => {
       const { dir, stdout, exitCode } = await runStart("echo 'step: npm run build -w app' && echo 'ok; done'");
       using _ = dir;
-      expect(stdout).toContain("-w app");
-      expect(stdout).not.toContain("--filter");
+      expect(stdout).toContain(" run build -w app");
+      expect(exitCode).toBe(0);
+    });
+
+    // Each command that runs a script rewrites it. `apps/app` has the script
+    // `cd ../.. && npm run build -w client`. Only bun's runner prints the name of the package.
+    it.each([
+      [["start"], "start"],
+      [["run", "--parallel", "start"], "start"],
+      [["run", "--filter", "app", "start"], "unused"],
+      [["install"], "postinstall"],
+    ])("bun %j runs the script of the folder", async (cmd, script) => {
+      const { dir, stdout, exitCode } = await runStart("npm run build -w client", cmd, script);
+      using _ = dir;
+      expect(stdout).toContain("@scope/web build: client-ok");
+      expect(exitCode).toBe(0);
+    });
+
+    // The value stays one word with its flag, so the shell makes two flags of it.
+    it("npm run hello --workspace={app,client} runs both packages", async () => {
+      const start = "npm run hello --workspace={app,client}";
+      const { dir, stdout, stderr, exitCode } = await runStart(start, ["run", "--shell=bun", "start"]);
+      using _ = dir;
+      expect(stderr).toContain(" run -w={app,client} hello\n");
+      expect(stdout).toContain("app hello: workspace-ok");
+      expect(stdout).toContain("@scope/web hello: client-hello");
       expect(exitCode).toBe(0);
     });
   });
diff --git a/test/cli/run/filter-workspace.test.ts b/test/cli/run/filter-workspace.test.ts
index 031bd4ee5686..691fe4d0c537 100644
--- a/test/cli/run/filter-workspace.test.ts
+++ b/test/cli/run/filter-workspace.test.ts
@@ -1548,6 +1548,7 @@ describe("auto-discovered bunfig.toml [run] section", () => {
   test.each([
     ["bun run --filter", ["run", "--filter", "dep0", "script"]],
     ["bun --filter", ["--filter", "dep0", "script"]],
+    ["bun run --workspace", ["run", "--workspace", "dep0", "script"]],
     ["bun run --workspaces", ["run", "--workspaces", "script"]],
   ])("%s applies [run] bun = true", (_, args) => {
     using dir = workspace("filter-bunfig-run-bun", "[run]\nbun = true\n");
diff --git a/test/cli/run/workspaces.test.ts b/test/cli/run/workspaces.test.ts
index 2ce4236a0c1b..f01dc252401a 100644
--- a/test/cli/run/workspaces.test.ts
+++ b/test/cli/run/workspaces.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, tempDir } from "harness";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
+import { join } from "path";
 
 describe.concurrent("bun run --workspaces", () => {
   test("runs script in all workspace packages", async () => {
@@ -130,3 +131,224 @@ describe.concurrent("bun run --workspaces", () => {
     }
   });
 });
+
+// `--workspace` takes what npm's flag takes: a package's name, its folder, or the folder above it.
+// Where a row says so, the packages are the ones that `npm run build -w <value>` of npm 11.16.0 runs in.
+describe.concurrent("bun run --workspace", () => {
+  // Every package prints its own word for `build`. The folder `client` holds `@scope/web`, and the
+  // package in `packages/b` has the name `client`. `lint-tool` has no `build` and `bare` has no
+  // script. `misc/anon` has no name. The `build` of `second` fails before the one of `first` ran.
+  async function run(cwd: string, args: string[], argv0?: string) {
+    const pkg = (name: string | undefined, build: string) => JSON.stringify({ name, scripts: { build } });
+    using dir = tempDir("run-workspace-flag", {
+      "package.json": JSON.stringify({
+        name: "root",
+        workspaces: [
+          "client",
+          "packages/*",
+          "packages/group/*",
+          "@org/*",
+          "tools/*",
+          "misc/*",
+          "order/*",
+          "dot/.hidden",
+        ],
+        scripts: { build: "echo ran-root" },
+      }),
+      "client/package.json": pkg("@scope/web", "echo ran-client"),
+      "packages/a/package.json": pkg("pkg-a", "echo ran-a"),
+      "packages/b/package.json": pkg("client", "echo ran-b"),
+      "packages/group/c/package.json": pkg("pkg-c", "echo ran-c"),
+      "@org/d/package.json": pkg("not-org-d", "echo ran-d"),
+      "dot/.hidden/package.json": pkg("hidden", "echo ran-hidden"),
+      "tools/lint/package.json": JSON.stringify({ name: "lint-tool", scripts: { lint: "echo ran-lint" } }),
+      "misc/anon/package.json": pkg(undefined, "echo ran-anon"),
+      "misc/bare/package.json": JSON.stringify({ name: "bare" }),
+      "order/first/package.json": pkg("first", "echo made > ../made.txt && echo ran-first"),
+      "order/second/package.json": pkg("second", "cat ../made.txt && echo ran-second"),
+      "file.js": "console.log(JSON.stringify(process.argv.slice(2)));",
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), ...args.map(arg => arg.replace("<root>", String(dir)))],
+      argv0,
+      env: bunEnv,
+      cwd: join(String(dir), cwd),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    const order = [...stdout.matchAll(/ran-([a-z]+)/g)].map(match => match[1]);
+    return { ran: order.toSorted(), order, stdout, stderr, exitCode };
+  }
+
+  // As npm.
+  test.each([
+    [".", ["-w", "client"], ["b", "client"]],
+    [".", ["-w=./client"], ["client"]],
+    [".", ["--workspace", "client/"], ["client"]],
+    [".", ["--workspace=@scope/web"], ["client"]],
+    [".", ["-w", "<root>/client"], ["client"]],
+    [".", ["-w", "packages"], ["a", "b"]],
+    [".", ["-w", "./packages"], ["a", "b"]],
+    [".", ["-w", "./packages/"], ["a", "b"]],
+    [".", ["-w", "packages/../packages"], ["a", "b"]],
+    [".", ["-w", "<root>/packages"], ["a", "b"]],
+    [".", ["-w", "packages/group"], ["c"]],
+    [".", ["-w", "@org/d"], ["d"]],
+    [".", ["-w", "@org"], ["d"]],
+    [".", ["-w", "./"], ["client"]],
+    [".", ["-w", "dot/.hidden"], ["hidden"]],
+    [".", ["-w", "misc/anon"], ["anon"]],
+    [".", ["-w", "misc", "--if-present"], ["anon"]],
+    [".", ["-w", "pkg-a", "-w", "@org"], ["a", "d"]],
+    [".", ["-w", "./client", "--workspaces"], ["client"]],
+    [".", ["-w", "pkg-a", "-w", "tools", "--if-present"], ["a"]],
+    // A path is read from the working directory, and a name from anywhere.
+    ["packages", ["-w", "a"], ["a"]],
+    ["packages", ["-w", "group"], ["c"]],
+    ["packages", ["-w", "./group"], ["c"]],
+    ["packages", ["-w", "group/"], ["c"]],
+    ["packages/a", ["-w", "../b"], ["b"]],
+    ["packages/a", ["-w", ".."], ["b"]],
+    ["packages/a", ["-w", "../"], ["b"]],
+    ["packages/a", ["-w", "."], ["a"]],
+    ["packages/a", ["-w", "pkg-c"], ["c"]],
+    // With `--filter`, a value is one more positive pattern. Only the packages that a value
+    // selects must have the script.
+    [".", ["-w", "pkg-a", "--filter", "@scope/*"], ["a", "client"]],
+    [".", ["-w", "packages", "--filter", "!pkg-a"], ["b"]],
+    [".", ["-w", "pkg-a", "--filter", "lint-tool"], ["a"]],
+  ])("in %s, %j runs build in %j", async (cwd, flags, expected) => {
+    const { ran, stderr, exitCode } = await run(cwd, ["run", ...flags, "build"]);
+    expect({ ran, stderr, exitCode }).toEqual({ ran: expected, stderr: "", exitCode: 0 });
+  });
+
+  // As npm: one package after another, in the order of the flags, and on after a failure.
+  test.each([
+    [["-w", "order/first", "-w", "order/second"], ["first", "second"], 0],
+    [["-w", "order/second", "-w", "order/first"], ["first"], 1],
+    [["-w", "pkg-a", "-w", "@org", "-w", "client"], ["a", "d", "client", "b"], 0],
+    [["-w", "packages"], ["a", "b"], 0],
+    [["--sequential", "-w", "pkg-c", "-w", "pkg-a"], ["c", "a"], 0],
+  ])("%j runs build in the order %j", async (flags, expected, code) => {
+    const { order, exitCode } = await run(".", ["run", ...flags, "build"]);
+    expect({ order, exitCode }).toEqual({ order: expected, exitCode: code });
+  });
+
+  test("--parallel runs build in the packages of a folder", async () => {
+    const { ran, exitCode } = await run(".", ["run", "--parallel", "-w", "packages", "build"]);
+    expect({ ran, exitCode }).toEqual({ ran: ["a", "b"], exitCode: 0 });
+  });
+
+  test("a value that selects nothing is reported when another one selects", async () => {
+    const { ran, stderr, exitCode } = await run(".", ["run", "-w", "pkg-a", "-w", "no-such-workspace", "build"]);
+    expect({ ran, stderr, exitCode }).toEqual({
+      ran: ["a"],
+      stderr: 'warn: No workspace packages matched --workspace "no-such-workspace"\n',
+      exitCode: 0,
+    });
+  });
+
+  // As npm, apart from `anon`: the folder `a` is not in the root, `*` does not match the dot
+  // folder in `dot`, and `--if-present` is about the script. A package without a name is selected
+  // by its path only.
+  test.each([
+    [".", ["-w", "no-such-workspace"], '--workspace "no-such-workspace"'],
+    [".", ["-w", "no-such-workspace", "--if-present"], '--workspace "no-such-workspace"'],
+    [".", ["-w", "a"], '--workspace "a"'],
+    [".", ["-w", "dot"], '--workspace "dot"'],
+    [".", ["-w", "anon"], '--workspace "anon"'],
+    ["packages/a", ["-w", "packages/group"], '--workspace "packages/group"'],
+    [".", ["--filter", "no-such-name", "-w", "lint"], '--workspace "lint" or --filter "no-such-name"'],
+    [".", ["-w", "no-such-workspace", "--filter", "!pkg-a"], '--workspace "no-such-workspace" or --filter "!pkg-a"'],
+    [".", ["-w", "pkg-a", "--filter", "!pkg-a"], '--workspace "pkg-a" or --filter "!pkg-a"'],
+  ])("in %s, %j selects nothing", async (cwd, flags, given) => {
+    const { stdout, stderr, exitCode } = await run(cwd, ["run", ...flags, "build"]);
+    expect({ stdout, stderr, exitCode }).toEqual({
+      stdout: "",
+      stderr: `error: No workspace packages matched ${given}\n`,
+      exitCode: 1,
+    });
+  });
+
+  // A Windows command line is too short for a path longer than the path buffer.
+  test.skipIf(isWindows)("a path longer than the path buffer selects nothing", async () => {
+    const long = "./" + Array(21).fill(Buffer.alloc(200, "a").toString()).join("/");
+    const { stdout, stderr, exitCode } = await run(".", ["run", "-w", long, "build"]);
+    expect({ stdout, stderr, exitCode }).toEqual({
+      stdout: "",
+      stderr: `error: No workspace packages matched --workspace "${long}"\n`,
+      exitCode: 1,
+    });
+  });
+
+  // npm fails too, after it ran the other packages. Here no script starts.
+  test.each([
+    [["-w", "pkg-a", "-w", "lint-tool"], "lint-tool"],
+    [["-w", "tools"], "lint-tool"],
+    [["-w", "pkg-a", "-w", "bare"], "bare"],
+    [["--filter", "pkg-a", "-w", "lint-tool"], "lint-tool"],
+    [["--parallel", "-w", "pkg-a", "-w", "tools"], "lint-tool"],
+  ])("%j fails for the package without the script", async (flags, name) => {
+    const { ran, stderr, exitCode } = await run(".", ["run", ...flags, "build"]);
+    expect({ ran, stderr, exitCode }).toEqual({
+      ran: [],
+      stderr: `error: Script "build" not found in package "${name}"\n`,
+      exitCode: 1,
+    });
+  });
+
+  // npm reads `-ws` as `--workspaces`, so `-w` takes no value that is glued to it. Bare `bun` has no `-w`.
+  test.each([
+    [["run", "-ws", "build"], "-ws"],
+    [["run", "-wclient", "build"], "-wclient"],
+    [["run", "-ws", "--help"], "-ws"],
+    [["-w", "client", "build"], "-w"],
+  ])("bun %j is not a workspace flag", async (args, word) => {
+    const { ran, stderr, exitCode } = await run(".", args);
+    expect({ ran, stderr, exitCode }).toEqual({ ran: [], stderr: `error: Invalid Argument '${word}'\n`, exitCode: 1 });
+  });
+
+  test("behind the name of the script, the flag is an argument of the script", async () => {
+    const { stdout, exitCode } = await run(".", ["run", "build", "-w", "client"]);
+    expect({ stdout, exitCode }).toEqual({ stdout: "ran-root -w client\n", exitCode: 0 });
+  });
+
+  // `node` has no such flag. The table of `bun run` also parses the arguments of bun as `node`.
+  test.each([
+    [["-w", "x", "file.js"], { stdout: "Usage: ", stderr: "error: Invalid Argument '-w'\n", exitCode: 1 }],
+    [["-w=x", "file.js"], { stdout: "Usage: ", stderr: "error: Invalid Argument '-w'\n", exitCode: 1 }],
+    [["--workspace=x", "file.js"], { stdout: "[]\n", stderr: "", exitCode: 0 }],
+    [["file.js", "-w", "x"], { stdout: '["-w","x"]\n', stderr: "", exitCode: 0 }],
+  ])("as node, %j is read as before", async (args, expected) => {
+    const { stdout, stderr, exitCode } = await run(".", args, "node");
+    // The usage on stdout is long.
+    expect({ stdout: stdout.slice(0, expected.stdout.length), stderr, exitCode }).toEqual(expected);
+  });
+
+  test("bun run --help lists the flag", async () => {
+    const { stdout, exitCode } = await run(".", ["run", "--help"]);
+    expect(stdout).toContain("-w, --workspace=<val>");
+    expect(exitCode).toBe(0);
+  });
+
+  test("a root that `workspaces` lists is selected by its path", async () => {
+    using dir = tempDir("run-workspace-listed-root", {
+      "package.json": JSON.stringify({ name: "root", workspaces: [".", "a"], scripts: { build: "echo ran-root" } }),
+      "a/package.json": JSON.stringify({ name: "a", scripts: { build: "echo ran-a" } }),
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", "-w", ".", "build"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect({ stdout, stderr, exitCode }).toEqual({
+      stdout: "root build: ran-root\nroot build: Exited with code 0\n",
+      stderr: "",
+      exitCode: 0,
+    });
+  });
+});