diff --git a/docs/cli/filter.md b/docs/cli/filter.md
new file mode 100644
index 00000000000000..4869c69a72e816
--- /dev/null
+++ b/docs/cli/filter.md
@@ -0,0 +1,58 @@
+Use the `--filter` flag to execute lifecycle scripts in multiple packages at once:
+
+```bash
+bun --filter <pattern> <script>
+```
+
+Say you have a monorepo with two packages: `packages/api` and `packages/frontend`, both with a `dev` script that will start a local development server. Normally, you would have to open two separate terminal tabs, cd into each package directory, and run `bun dev`:
+
+```bash
+cd packages/api
+bun dev
+
+# in another terminal
+cd packages/frontend
+bun dev
+```
+
+Using `--filter`, you can run the `dev` script in both packages at once:
+
+```bash
+bun --filter '*' dev 
+```
+
+Both commands will be run in parallel, and you will see a nice terminal UI showing their respective outputs:
+![Terminal Output](https://github.com/oven-sh/bun/assets/48869301/2a103e42-9921-4c33-948f-a1ad6e6bac71)
+
+
+## Matching
+
+`--filter` accepts a pattern to match specific packages, either by name or by path. Patterns have full support for glob syntax.
+
+### Package Name `--filter <pattern>`
+
+Name patterns select packages based on the package name, as specified in `package.json`. For example, if you have packages `pkga`, `pkgb` and `other`, you can match all packages with `*`, only `pkga` and `pkgb` with `pkg*`, and a specific package by providing the full name of the package.
+
+### Package Path `--filter ./<glob>`
+
+Path patterns are specified by starting the pattern with `./`, and will select all packages in directories that match the pattern. For example, to match all packages in subdirectories of `packages`, you can use `--filter './packages/**'`. To match a package located in `pkgs/foo`, use `--filter ./pkgs/foo`.
+
+## Workspaces
+
+Filters respect your [workspace configuration](/docs/install/workspaces.md): If you have a `package.json` file that specifies which packages are part of the workspace,
+`--filter` will be restricted to only these packages. Also, in a workspace you can use `--filter` to run scripts in packages that are located anywhere in the workspace:
+
+```bash
+# Packages
+# src/foo
+# src/bar
+
+# in src/bar: runs myscript in src/foo, no need to cd!
+bun run --filter foo myscript
+```
+
+## Dependency Order
+Bun will respect package dependency order when running scripts. Say you have a package `foo` that depends on another package `bar` in your workspace, and both packages have a `build` script. When you run `bun --filter '*' build`, you will notice that `foo` will only start running once `bar` is done.
+
+### Cyclic Dependencies
+
diff --git a/docs/cli/run.md b/docs/cli/run.md
index effe8d831aa9eb..2ea6295adfef8d 100644
--- a/docs/cli/run.md
+++ b/docs/cli/run.md
@@ -151,6 +151,19 @@ By default, Bun respects this shebang and executes the script with `node`. Howev
 $ bun run --bun vite
 ```
 
+### Filtering
+
+in monorepos containing multiple packages, you can use the `--filter` argument to execute scripts in many packages at once.
+
+Use `bun run --filter <name_pattern> <script>` to execute `<script>` in all packages whose name matches `<name_pattern>`.
+For example, if you have subdirectories containing packages named `foo`, `bar` and `baz`, running 
+```bash
+bun run --filter 'ba*' <script>
+```
+will execute `<script>` in both `bar` and `baz`, but not in `foo`.
+
+Find more details in the docs page for [filter](/docs/cli/filter.md).
+
 ## `bun run -` to pipe code from stdin
 
 `bun run -` lets you read JavaScript, TypeScript, TSX, or JSX from stdin and execute it without writing to a temporary file first.
diff --git a/docs/install/workspaces.md b/docs/install/workspaces.md
index 8df1d4304f9b00..30e535b9cb40c9 100644
--- a/docs/install/workspaces.md
+++ b/docs/install/workspaces.md
@@ -61,6 +61,7 @@ Workspaces have a couple major benefits.
 
 - **Code can be split into logical parts.** If one package relies on another, you can simply add it as a dependency in `package.json`. If package `b` depends on `a`, `bun install` will install your local `packages/a` directory into `node_modules` instead of downloading it from the npm registry.
 - **Dependencies can be de-duplicated.** If `a` and `b` share a common dependency, it will be _hoisted_ to the root `node_modules` directory. This reduces redundant disk usage and minimizes "dependency hell" issues associated with having multiple versions of a package installed simultaneously.
+- **Run scripts in multiple pacakges.** You can use the [`--filter` flag](/docs/cli/filter.md) to easily run `package.json` scripts in multiple packages in your workspace.
 
 {% callout %}
 ⚡️ **Speed** — Installs are fast, even for big monorepos. Bun installs the [Remix](https://github.com/remix-run/remix) monorepo in about `500ms` on Linux.
diff --git a/docs/nav.ts b/docs/nav.ts
index 9f90ed22bae8d0..841d28ff1fb70a 100644
--- a/docs/nav.ts
+++ b/docs/nav.ts
@@ -180,6 +180,9 @@ export default {
     page("install/lifecycle", "Lifecycle scripts", {
       description: "How Bun handles package lifecycle scripts with trustedDependencies",
     }),
+    page("cli/filter", "Filter", {
+      description: "Run scripts in multiple packages in parallel",
+    }),
     page("install/lockfile", "Lockfile", {
       description:
         "Bun's binary lockfile `bun.lockb` tracks your resolved dependency tree, making future installs fast and repeatable.",
diff --git a/src/bun.js/api/bun/process.zig b/src/bun.js/api/bun/process.zig
index 41c239b14dfd27..3c6347a28d033b 100644
--- a/src/bun.js/api/bun/process.zig
+++ b/src/bun.js/api/bun/process.zig
@@ -81,6 +81,7 @@ pub const Rusage = if (Environment.isWindows) win_rusage else std.os.rusage;
 const Subprocess = JSC.Subprocess;
 const LifecycleScriptSubprocess = bun.install.LifecycleScriptSubprocess;
 const ShellSubprocess = bun.shell.ShellSubprocess;
+const ProcessHandle = @import("../../../cli/filter_run.zig").ProcessHandle;
 // const ShellSubprocessMini = bun.shell.ShellSubprocessMini;
 pub const ProcessExitHandler = struct {
     ptr: TaggedPointer = TaggedPointer.Null,
@@ -93,6 +94,7 @@ pub const ProcessExitHandler = struct {
             Subprocess,
             LifecycleScriptSubprocess,
             ShellSubprocess,
+            ProcessHandle,
 
             SyncProcess,
         },
@@ -116,6 +118,10 @@ pub const ProcessExitHandler = struct {
                 const subprocess = this.ptr.as(LifecycleScriptSubprocess);
                 subprocess.onProcessExit(process, status, rusage);
             },
+            .ProcessHandle => {
+                const subprocess = this.ptr.as(ProcessHandle);
+                subprocess.onProcessExit(process, status, rusage);
+            },
             @field(TaggedPointer.Tag, bun.meta.typeBaseName(@typeName(ShellSubprocess))) => {
                 const subprocess = this.ptr.as(ShellSubprocess);
                 subprocess.onProcessExit(process, status, rusage);
diff --git a/src/cli.zig b/src/cli.zig
index 660791a44ed37a..09e6524391b3f5 100644
--- a/src/cli.zig
+++ b/src/cli.zig
@@ -34,6 +34,7 @@ const bundler = bun.bundler;
 const DotEnv = @import("./env_loader.zig");
 const RunCommand_ = @import("./cli/run_command.zig").RunCommand;
 const CreateCommand_ = @import("./cli/create_command.zig").CreateCommand;
+const FilterRun = @import("./cli/filter_run.zig");
 
 const fs = @import("fs.zig");
 const Router = @import("./router.zig");
@@ -186,6 +187,7 @@ pub const Arguments = struct {
     };
 
     const auto_or_run_params = [_]ParamType{
+        clap.parseParam("--filter <STR>...                 Run a script in all workspace packages matching the pattern") catch unreachable,
         clap.parseParam("-b, --bun                         Force a script or package to use Bun's runtime instead of Node.js (via symlinking node)") catch unreachable,
         clap.parseParam("--shell <STR>                     Control the shell used for package.json scripts. Supports either 'bun' or 'system'") catch unreachable,
     };
@@ -432,6 +434,10 @@ pub const Arguments = struct {
             cwd = try bun.getcwdAlloc(allocator);
         }
 
+        if (cmd == .RunCommand or cmd == .AutoCommand) {
+            ctx.filters = args.options("--filter");
+        }
+
         if (cmd == .TestCommand) {
             if (args.option("--timeout")) |timeout_ms| {
                 if (timeout_ms.len > 0) {
@@ -1154,6 +1160,8 @@ pub const Command = struct {
         bundler_options: BundlerOptions = BundlerOptions{},
         runtime_options: RuntimeOptions = RuntimeOptions{},
 
+        filters: []const []const u8 = &[_][]const u8{},
+
         preloads: []const string = &[_]string{},
         has_loaded_global_config: bool = false,
 
@@ -1703,6 +1711,13 @@ pub const Command = struct {
                 if (comptime bun.fast_debug_build_mode and bun.fast_debug_build_cmd != .RunCommand) unreachable;
                 const ctx = try Command.Context.create(allocator, log, .RunCommand);
 
+                if (ctx.filters.len > 0) {
+                    FilterRun.runScriptsWithFilter(ctx) catch |err| {
+                        Output.prettyErrorln("<r><red>error<r>: {s}", .{@errorName(err)});
+                        Global.exit(1);
+                    };
+                }
+
                 if (ctx.positionals.len > 0) {
                     if (try RunCommand.exec(ctx, false, true, false)) {
                         return;
@@ -1725,6 +1740,7 @@ pub const Command = struct {
             },
             .AutoCommand => {
                 if (comptime bun.fast_debug_build_mode and bun.fast_debug_build_cmd != .AutoCommand) unreachable;
+
                 var ctx = Command.Context.create(allocator, log, .AutoCommand) catch |e| {
                     switch (e) {
                         error.MissingEntryPoint => {
@@ -1737,6 +1753,13 @@ pub const Command = struct {
                     }
                 };
 
+                if (ctx.filters.len > 0) {
+                    FilterRun.runScriptsWithFilter(ctx) catch |err| {
+                        Output.prettyErrorln("<r><red>error<r>: {s}", .{@errorName(err)});
+                        Global.exit(1);
+                    };
+                }
+
                 if (ctx.runtime_options.eval.script.len > 0) {
                     const trigger = bun.pathLiteral("/[eval]");
                     var entry_point_buf: [bun.MAX_PATH_BYTES + trigger.len]u8 = undefined;
@@ -1821,6 +1844,9 @@ pub const Command = struct {
                 }
 
                 if (ctx.positionals.len > 0 and extension.len == 0) {
+                    if (ctx.filters.len > 0) {
+                        Output.prettyln("<r><yellow>warn<r>: Filters are ignored for auto command", .{});
+                    }
                     if (try RunCommand.exec(ctx, true, false, true)) {
                         return;
                     }
diff --git a/src/cli/filter_arg.zig b/src/cli/filter_arg.zig
new file mode 100644
index 00000000000000..d5d5bfb09b0904
--- /dev/null
+++ b/src/cli/filter_arg.zig
@@ -0,0 +1,258 @@
+const std = @import("std");
+const root = @import("root");
+const bun = root.bun;
+const string = bun.string;
+const Output = bun.Output;
+const Global = bun.Global;
+const strings = bun.strings;
+const json_parser = bun.JSON;
+const Glob = @import("../glob.zig");
+
+const Package = @import("../install/lockfile.zig").Package;
+
+const SKIP_LIST = .{
+    // skip hidden directories
+    ".",
+
+    // skip node_modules
+    "node_modules",
+
+    // skip .git folder
+    ".git",
+};
+fn globIgnoreFn(val: []const u8) bool {
+    if (val.len == 0) {
+        return false;
+    }
+
+    inline for (SKIP_LIST) |skip| {
+        if (strings.eqlComptime(val, skip)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+const GlobWalker = Glob.GlobWalker_(globIgnoreFn, Glob.DirEntryAccessor, false);
+
+pub fn getCandidatePackagePatterns(allocator: std.mem.Allocator, log: *bun.logger.Log, out_patterns: *std.ArrayList([]u8), workdir_: []const u8, root_buf: *bun.PathBuffer) ![]const u8 {
+    bun.JSAst.Expr.Data.Store.create(bun.default_allocator);
+    bun.JSAst.Stmt.Data.Store.create(bun.default_allocator);
+
+    defer {
+        bun.JSAst.Expr.Data.Store.reset();
+        bun.JSAst.Stmt.Data.Store.reset();
+    }
+
+    var workdir = workdir_;
+
+    while (true) : (workdir = std.fs.path.dirname(workdir) orelse break) {
+        var name_buf: bun.PathBuffer = undefined;
+        const json_path: [:0]const u8 = bun.path.joinAbsStringBufZ(workdir, name_buf[0..], &.{"package.json"}, .auto);
+
+        log.msgs.clearRetainingCapacity();
+        log.errors = 0;
+        log.warnings = 0;
+
+        const json_source = switch (bun.sys.File.toSource(json_path, allocator)) {
+            .err => |err| {
+                switch (err.getErrno()) {
+                    .NOENT, .ACCES, .PERM => continue,
+                    else => |errno| return bun.errnoToZigErr(errno),
+                }
+            },
+            .result => |source| source,
+        };
+        defer allocator.free(json_source.contents);
+
+        const json = try json_parser.ParseJSONUTF8(&json_source, log, allocator);
+
+        const prop = json.asProperty("workspaces") orelse continue;
+
+        const json_array = switch (prop.expr.data) {
+            .e_array => |arr| arr,
+            .e_object => |obj| if (obj.get("packages")) |packages| switch (packages.data) {
+                .e_array => |arr| arr,
+                else => break,
+            } else break,
+            else => break,
+        };
+
+        for (json_array.slice()) |expr| {
+            switch (expr.data) {
+                .e_string => |pattern_expr| {
+                    const size = pattern_expr.data.len + "/package.json".len;
+                    var pattern = try allocator.alloc(u8, size);
+                    @memcpy(pattern[0..pattern_expr.data.len], pattern_expr.data);
+                    @memcpy(pattern[pattern_expr.data.len..size], "/package.json");
+
+                    try out_patterns.append(pattern);
+                },
+                else => {
+                    Output.prettyErrorln("<r><red>error<r>: Failed to parse \"workspaces\" property: all items must be strings", .{});
+                    Global.exit(1);
+                },
+            }
+        }
+
+        const parent_trimmed = strings.withoutTrailingSlash(workdir);
+        @memcpy(root_buf[0..parent_trimmed.len], parent_trimmed);
+        return root_buf[0..parent_trimmed.len];
+    }
+
+    // if we were not able to find a workspace root, we simply glob for all package.json files
+    try out_patterns.append(try allocator.dupe(u8, "**/package.json"));
+    const root_dir = strings.withoutTrailingSlash(workdir_);
+    @memcpy(root_buf[0..root_dir.len], root_dir);
+    return root_buf[0..root_dir.len];
+}
+
+pub const FilterSet = struct {
+    allocator: std.mem.Allocator,
+    filters: []Pattern,
+    has_name_filters: bool = false,
+
+    const Pattern = struct {
+        codepoints: []u32,
+        kind: enum {
+            name,
+            path,
+        },
+        // negate: bool = false,
+    };
+
+    pub fn init(allocator: std.mem.Allocator, filters: []const []const u8, cwd: []const u8) !FilterSet {
+        var buf: bun.PathBuffer = undefined;
+        // TODO fixed buffer allocator with fallback?
+        var self = FilterSet{ .allocator = allocator, .filters = try allocator.alloc(Pattern, filters.len) };
+        for (self.filters, filters) |*pattern, filter_utf8_| {
+            var filter_utf8 = filter_utf8_;
+            const is_path = filter_utf8.len > 0 and filter_utf8[0] == '.';
+            if (is_path) {
+                const parts = [_]string{filter_utf8};
+                filter_utf8 = bun.path.joinAbsStringBuf(cwd, &buf, &parts, .auto);
+            }
+            var filter_utf32 = try std.ArrayListUnmanaged(u32).initCapacity(allocator, filter_utf8.len + 1);
+            var codepointer_iter = strings.UnsignedCodepointIterator.init(filter_utf8);
+            var cursor = strings.UnsignedCodepointIterator.Cursor{};
+            while (codepointer_iter.next(&cursor)) {
+                if (cursor.c == @as(u32, '\\')) {
+                    try filter_utf32.append(self.allocator, cursor.c);
+                }
+                try filter_utf32.append(self.allocator, cursor.c);
+            }
+            self.has_name_filters = self.has_name_filters or !is_path;
+            pattern.* = Pattern{
+                .codepoints = filter_utf32.items,
+                .kind = if (is_path) .path else .name,
+            };
+        }
+        return self;
+    }
+
+    pub fn deinit(self: *FilterSet) void {
+        for (self.filters) |filter| {
+            // TODO is this free correct? we're freeing only part of the array
+            self.allocator.free(filter.codepoints);
+        }
+        self.allocator.free(self.filters);
+    }
+
+    pub fn matchesPath(self: *FilterSet, path: []const u8) bool {
+        for (self.filters) |filter| {
+            if (Glob.matchImpl(filter.codepoints, path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    pub fn matchesPathName(self: *FilterSet, path: []const u8, name: []const u8) bool {
+        for (self.filters) |filter| {
+            const target = switch (filter.kind) {
+                .name => name,
+                .path => path,
+            };
+            if (Glob.matchImpl(filter.codepoints, target)) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+
+pub const PackageFilterIterator = struct {
+    patterns: []const []const u8,
+    pattern_idx: usize = 0,
+    root_dir: []const u8,
+
+    walker: GlobWalker = undefined,
+    iter: GlobWalker.Iterator = undefined,
+    valid: bool = false,
+
+    allocator: std.mem.Allocator,
+
+    pub fn init(allocator: std.mem.Allocator, patterns: []const []const u8, root_dir: []const u8) !PackageFilterIterator {
+        return PackageFilterIterator{
+            .patterns = patterns,
+            .allocator = allocator,
+            .root_dir = root_dir,
+        };
+    }
+
+    pub fn deinit(self: *PackageFilterIterator) void {
+        if (self.valid) {
+            self.deinitWalker();
+        }
+    }
+
+    fn walkerNext(self: *PackageFilterIterator) !?[]const u8 {
+        while (true) {
+            switch (try self.iter.next()) {
+                .err => |err| {
+                    Output.prettyErrorln("Error: {}", .{err});
+                    continue;
+                },
+                .result => |path| {
+                    return path;
+                },
+            }
+        }
+    }
+
+    fn initWalker(self: *PackageFilterIterator) !void {
+        const pattern = self.patterns[self.pattern_idx];
+        var arena = std.heap.ArenaAllocator.init(self.allocator);
+        errdefer arena.deinit();
+        const cwd = try arena.allocator().dupe(u8, self.root_dir);
+        try (try self.walker.initWithCwd(&arena, pattern, cwd, true, true, false, true, true)).unwrap();
+        self.iter = GlobWalker.Iterator{ .walker = &self.walker };
+        try (try self.iter.init()).unwrap();
+    }
+
+    fn deinitWalker(self: *PackageFilterIterator) void {
+        self.walker.deinit(false);
+        self.iter.deinit();
+    }
+
+    pub fn next(self: *PackageFilterIterator) !?[]const u8 {
+        while (true) {
+            if (!self.valid) {
+                if (self.pattern_idx < self.patterns.len) {
+                    try self.initWalker();
+                    self.valid = true;
+                } else {
+                    return null;
+                }
+            }
+            if (try self.walkerNext()) |path| {
+                return path;
+            } else {
+                self.valid = false;
+                self.pattern_idx += 1;
+                self.deinitWalker();
+            }
+        }
+    }
+};
diff --git a/src/cli/filter_run.zig b/src/cli/filter_run.zig
new file mode 100644
index 00000000000000..a42874f8f118f6
--- /dev/null
+++ b/src/cli/filter_run.zig
@@ -0,0 +1,639 @@
+const bun = @import("root").bun;
+const Output = bun.Output;
+const Global = bun.Global;
+const Environment = bun.Environment;
+const std = @import("std");
+const Fs = @import("../fs.zig");
+const RunCommand = @import("run_command.zig").RunCommand;
+const DependencyMap = @import("../resolver/package_json.zig").DependencyMap;
+const SemverString = @import("../install/semver.zig").String;
+
+const CLI = bun.CLI;
+const Command = CLI.Command;
+
+const bundler = bun.bundler;
+
+const FilterArg = @import("filter_arg.zig");
+
+const ScriptConfig = struct {
+    package_json_path: []u8,
+    package_name: []const u8,
+    script_name: []const u8,
+    script_content: []const u8,
+    combined: [:0]const u8,
+    deps: DependencyMap,
+
+    // $PATH must be set per script because it contains
+    // node_modules/.bin
+    // ../node_modules/.bin
+    // ../../node_modules/.bin
+    // and so forth, in addition to the user's $PATH.
+    PATH: []const u8,
+
+    fn cmp(_: void, a: @This(), b: @This()) bool {
+        return bun.strings.cmpStringsAsc({}, a.package_name, b.package_name);
+    }
+};
+
+pub const ProcessHandle = struct {
+    const This = @This();
+
+    config: *ScriptConfig,
+    state: *State,
+
+    stdout: bun.io.BufferedReader = bun.io.BufferedReader.init(This),
+    stderr: bun.io.BufferedReader = bun.io.BufferedReader.init(This),
+    buffer: std.ArrayList(u8) = std.ArrayList(u8).init(bun.default_allocator),
+
+    process: ?struct {
+        ptr: *bun.spawn.Process,
+        status: bun.spawn.Status = .running,
+    } = null,
+    options: bun.spawn.SpawnOptions,
+
+    start_time: ?std.time.Instant = null,
+    end_time: ?std.time.Instant = null,
+
+    remaining_dependencies: usize = 0,
+    dependents: std.ArrayList(*This) = std.ArrayList(*This).init(bun.default_allocator),
+    visited: bool = false,
+    visiting: bool = false,
+
+    fn start(this: *This) !void {
+        this.state.remaining_scripts += 1;
+        const handle = this;
+
+        var argv = [_:null]?[*:0]const u8{ this.state.shell_bin, if (Environment.isPosix) "-c" else "exec", this.config.combined, null };
+
+        this.start_time = std.time.Instant.now() catch null;
+        var spawned: bun.spawn.SpawnProcessResult = brk: {
+
+            // Get the envp with the PATH configured
+            // There's probably a more optimal way to do this where you have a std.ArrayList shared
+            // instead of creating a new one for each process
+            var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
+            defer arena.deinit();
+            const original_path = this.state.env.map.get("PATH") orelse "";
+            this.state.env.map.put("PATH", this.config.PATH) catch bun.outOfMemory();
+            defer this.state.env.map.put("PATH", original_path) catch bun.outOfMemory();
+            const envp = try this.state.env.map.createNullDelimitedEnvMap(arena.allocator());
+
+            break :brk try (try bun.spawn.spawnProcess(&this.options, argv[0..], envp)).unwrap();
+        };
+        var process = spawned.toProcess(this.state.event_loop, false);
+
+        handle.stdout.setParent(handle);
+        handle.stderr.setParent(handle);
+
+        if (Environment.isWindows) {
+            handle.stdout.source = .{ .pipe = this.options.stdout.buffer };
+            handle.stderr.source = .{ .pipe = this.options.stderr.buffer };
+        }
+
+        if (Environment.isPosix) {
+            if (spawned.stdout) |stdout| {
+                try handle.stdout.start(stdout, true).unwrap();
+            }
+            if (spawned.stderr) |stderr| {
+                try handle.stderr.start(stderr, true).unwrap();
+            }
+        } else {
+            try handle.stdout.startWithCurrentPipe().unwrap();
+            try handle.stderr.startWithCurrentPipe().unwrap();
+        }
+
+        process.setExitHandler(handle);
+
+        try process.watch(this.state.event_loop).unwrap();
+
+        this.process = .{ .ptr = process };
+    }
+
+    pub fn onReadChunk(this: *This, chunk: []const u8, hasMore: bun.io.ReadState) bool {
+        _ = hasMore;
+        this.state.readChunk(this, chunk) catch {};
+        return true;
+    }
+
+    pub fn onReaderDone(this: *This) void {
+        _ = this;
+    }
+
+    pub fn onReaderError(this: *This, err: bun.sys.Error) void {
+        _ = this;
+        _ = err;
+    }
+
+    pub fn onProcessExit(this: *This, proc: *bun.spawn.Process, status: bun.spawn.Status, _: *const bun.spawn.Rusage) void {
+        this.process.?.status = status;
+        this.end_time = std.time.Instant.now() catch null;
+        // We just leak the process because we're going to exit anyway after all processes are done
+        _ = proc;
+        this.state.processExit(this) catch {};
+    }
+
+    pub fn eventLoop(this: *This) *bun.JSC.MiniEventLoop {
+        return this.state.event_loop;
+    }
+
+    pub fn loop(this: *This) *bun.uws.Loop {
+        return this.state.event_loop.loop;
+    }
+};
+
+fn fmt(comptime str: []const u8) []const u8 {
+    return Output.prettyFmt(str, true);
+}
+
+const State = struct {
+    const This = @This();
+
+    handles: []ProcessHandle,
+    event_loop: *bun.JSC.MiniEventLoop,
+    remaining_scripts: usize = 0,
+    // buffer for batched output
+    draw_buf: std.ArrayList(u8) = std.ArrayList(u8).init(bun.default_allocator),
+    last_lines_written: usize = 0,
+    pretty_output: bool,
+    shell_bin: [:0]const u8,
+    aborted: bool = false,
+    env: *bun.DotEnv.Loader,
+
+    pub fn isDone(this: *This) bool {
+        return this.remaining_scripts == 0;
+    }
+
+    const ElideResult = struct {
+        content: []const u8,
+        elided_count: usize,
+    };
+
+    fn readChunk(this: *This, handle: *ProcessHandle, chunk: []const u8) !void {
+        if (this.pretty_output) {
+            handle.buffer.appendSlice(chunk) catch bun.outOfMemory();
+            this.redraw(false) catch {};
+        } else {
+            var content = chunk;
+            this.draw_buf.clearRetainingCapacity();
+            if (handle.buffer.items.len > 0) {
+                if (std.mem.indexOfScalar(u8, content, '\n')) |i| {
+                    try handle.buffer.appendSlice(content[0 .. i + 1]);
+                    content = content[i + 1 ..];
+                    try this.draw_buf.writer().print("{s} {s}: {s}", .{ handle.config.package_name, handle.config.script_name, handle.buffer.items });
+                    handle.buffer.clearRetainingCapacity();
+                } else {
+                    try handle.buffer.appendSlice(content);
+                    return;
+                }
+            }
+            while (std.mem.indexOfScalar(u8, content, '\n')) |i| {
+                const line = content[0 .. i + 1];
+                try this.draw_buf.writer().print("{s} {s}: {s}", .{ handle.config.package_name, handle.config.script_name, line });
+                content = content[i + 1 ..];
+            }
+            if (content.len > 0) {
+                try handle.buffer.appendSlice(content);
+            }
+            this.flushDrawBuf();
+        }
+    }
+
+    fn processExit(this: *This, handle: *ProcessHandle) !void {
+        this.remaining_scripts -= 1;
+        if (!this.aborted) {
+            for (handle.dependents.items) |dependent| {
+                dependent.remaining_dependencies -= 1;
+                if (dependent.remaining_dependencies == 0) {
+                    dependent.start() catch {
+                        Output.prettyErrorln("<r><red>error<r>: Failed to start process", .{});
+                        Global.exit(1);
+                    };
+                }
+            }
+        }
+        if (this.pretty_output) {
+            this.redraw(false) catch {};
+        } else {
+            this.draw_buf.clearRetainingCapacity();
+            // flush any remaining buffer
+            if (handle.buffer.items.len > 0) {
+                try this.draw_buf.writer().print("{s}: {s}\n", .{ handle.config.package_name, handle.buffer.items });
+                handle.buffer.clearRetainingCapacity();
+            }
+            // print exit status
+            switch (handle.process.?.status) {
+                .exited => |exited| {
+                    try this.draw_buf.writer().print("{s} {s}: Exited with code {d}\n", .{ handle.config.package_name, handle.config.script_name, exited.code });
+                },
+                .signaled => |signal| {
+                    try this.draw_buf.writer().print("{s} {s}: Signaled with code {s}\n", .{ handle.config.package_name, handle.config.script_name, @tagName(signal) });
+                },
+                else => {},
+            }
+            this.flushDrawBuf();
+        }
+    }
+
+    fn elide(data_: []const u8, max_lines: ?usize) ElideResult {
+        var data = data_;
+        if (data.len == 0) return .{ .content = &.{}, .elided_count = 0 };
+        if (data[data.len - 1] == '\n') {
+            data = data[0 .. data.len - 1];
+        }
+        if (max_lines == null) return .{ .content = data, .elided_count = 0 };
+        var i: usize = data.len;
+        var lines: usize = 0;
+        while (i > 0) : (i -= 1) {
+            if (data[i - 1] == '\n') {
+                lines += 1;
+                if (lines >= max_lines.?) {
+                    break;
+                }
+            }
+        }
+        const content = if (i >= data.len) &.{} else data[i..];
+        var elided: usize = 0;
+        while (i > 0) : (i -= 1) {
+            if (data[i - 1] == '\n') {
+                elided += 1;
+            }
+        }
+        return .{ .content = content, .elided_count = elided };
+    }
+
+    fn redraw(this: *This, is_abort: bool) !void {
+        if (!this.pretty_output) return;
+        this.draw_buf.clearRetainingCapacity();
+        try this.draw_buf.appendSlice("\x1b[?2026h");
+        if (this.last_lines_written > 0) {
+            // move cursor to the beginning of the line and clear it
+            try this.draw_buf.appendSlice("\x1b[0G\x1b[K");
+            for (0..this.last_lines_written) |_| {
+                // move cursor up and clear the line
+                try this.draw_buf.appendSlice("\x1b[1A\x1b[K");
+            }
+        }
+        for (this.handles) |*handle| {
+            // normally we truncate the output to 10 lines, but on abort we print everything to aid debugging
+            const e = elide(handle.buffer.items, if (is_abort) null else 10);
+            try this.draw_buf.writer().print(fmt("<b>{s}<r> {s} $ <d>{s}<r>\n"), .{ handle.config.package_name, handle.config.script_name, handle.config.script_content });
+            if (e.elided_count > 0) {
+                try this.draw_buf.writer().print(
+                    fmt("<cyan>│<r> <d>[{d} lines elided]<r>\n"),
+                    .{e.elided_count},
+                );
+            }
+            var content = e.content;
+            while (std.mem.indexOfScalar(u8, content, '\n')) |i| {
+                const line = content[0 .. i + 1];
+                try this.draw_buf.appendSlice(fmt("<cyan>│<r> "));
+                try this.draw_buf.appendSlice(line);
+                content = content[i + 1 ..];
+            }
+            if (content.len > 0) {
+                try this.draw_buf.appendSlice(fmt("<cyan>│<r> "));
+                try this.draw_buf.appendSlice(content);
+                try this.draw_buf.append('\n');
+            }
+            try this.draw_buf.appendSlice(fmt("<cyan>└─<r> "));
+            if (handle.process) |proc| {
+                switch (proc.status) {
+                    .running => try this.draw_buf.appendSlice(fmt("<cyan>Running...<r>\n")),
+                    .exited => |exited| {
+                        if (exited.code == 0) {
+                            if (handle.start_time != null and handle.end_time != null) {
+                                const duration = handle.end_time.?.since(handle.start_time.?);
+                                const ms = @as(f64, @floatFromInt(duration)) / 1_000_000.0;
+                                if (ms > 1000.0) {
+                                    try this.draw_buf.writer().print(fmt("<cyan>Done in {d:.2} s<r>\n"), .{ms / 1_000.0});
+                                } else {
+                                    try this.draw_buf.writer().print(fmt("<cyan>Done in {d:.0} ms<r>\n"), .{ms});
+                                }
+                            } else {
+                                try this.draw_buf.appendSlice(fmt("<cyan>Done<r>\n"));
+                            }
+                        } else {
+                            try this.draw_buf.writer().print(fmt("<red>Exited with code {d}<r>\n"), .{exited.code});
+                        }
+                    },
+                    .signaled => |code| {
+                        if (code == .SIGINT) {
+                            try this.draw_buf.writer().print(fmt("<red>Interrupted<r>\n"), .{});
+                        } else {
+                            try this.draw_buf.writer().print(fmt("<red>Signaled with code {s}<r>\n"), .{@tagName(code)});
+                        }
+                    },
+                    .err => {
+                        try this.draw_buf.appendSlice(fmt("<red>Error<r>\n"));
+                    },
+                }
+            } else {
+                try this.draw_buf.writer().print(fmt("<cyan><d>Waiting for {d} other script(s)<r>\n"), .{handle.remaining_dependencies});
+            }
+        }
+        try this.draw_buf.appendSlice("\x1b[?2026l");
+        this.last_lines_written = 0;
+        for (this.draw_buf.items) |c| {
+            if (c == '\n') {
+                this.last_lines_written += 1;
+            }
+        }
+        this.flushDrawBuf();
+    }
+
+    fn flushDrawBuf(this: *This) void {
+        std.io.getStdOut().writeAll(this.draw_buf.items) catch {};
+    }
+
+    pub fn abort(this: *This) void {
+        // we perform an abort by sending SIGINT to all processes
+        this.aborted = true;
+        for (this.handles) |*handle| {
+            if (handle.process) |*proc| {
+                // if we get an error here we simply ignore it
+                _ = proc.ptr.kill(std.os.SIG.INT);
+            }
+        }
+    }
+
+    pub fn finalize(this: *This) void {
+        if (this.aborted) {
+            this.redraw(true) catch {};
+        }
+    }
+};
+
+const AbortHandler = struct {
+    const This = @This();
+
+    var should_abort = false;
+
+    fn posixSignalHandler(sig: i32, info: *const std.os.siginfo_t, _: ?*const anyopaque) callconv(.C) void {
+        _ = sig;
+        _ = info;
+        should_abort = true;
+    }
+
+    fn windowsCtrlHandler(dwCtrlType: std.os.windows.DWORD) callconv(std.os.windows.WINAPI) std.os.windows.BOOL {
+        if (dwCtrlType == std.os.windows.CTRL_C_EVENT) {
+            should_abort = true;
+            return std.os.windows.TRUE;
+        }
+        return std.os.windows.FALSE;
+    }
+
+    pub fn install() void {
+        if (Environment.isPosix) {
+            const action = std.os.Sigaction{
+                .handler = .{ .sigaction = AbortHandler.posixSignalHandler },
+                .mask = std.os.empty_sigset,
+                .flags = std.os.SA.SIGINFO | std.os.SA.RESTART | std.os.SA.RESETHAND,
+            };
+            // if we can't set the handler, we just ignore it
+            std.os.sigaction(std.os.SIG.INT, &action, null) catch |err| {
+                if (Environment.isDebug) {
+                    Output.warn("Failed to set abort handler: {s}\n", .{@errorName(err)});
+                }
+            };
+        } else {
+            const res = bun.windows.SetConsoleCtrlHandler(windowsCtrlHandler, std.os.windows.TRUE);
+            if (res == 0) {
+                if (Environment.isDebug) {
+                    Output.warn("Failed to set abort handler\n", .{});
+                }
+            }
+        }
+    }
+
+    pub fn uninstall() void {
+        // only necessary on Windows, as on posix we pass the SA_RESETHAND flag
+        if (Environment.isWindows) {
+            // restores default Ctrl+C behavior
+            _ = bun.windows.SetConsoleCtrlHandler(null, std.os.windows.FALSE);
+        }
+    }
+};
+
+fn windowsIsTerminal() bool {
+    const res = bun.windows.GetFileType(bun.STDOUT_FD.cast());
+    return res == bun.windows.FILE_TYPE_CHAR;
+}
+
+pub fn runScriptsWithFilter(ctx: Command.Context) !noreturn {
+    const script_name = if (ctx.positionals.len > 1) ctx.positionals[1] else if (ctx.positionals.len > 0) ctx.positionals[0] else {
+        Output.prettyErrorln("<r><red>error<r>: No script name provided", .{});
+        Global.exit(1);
+    };
+    const pre_script_name = try ctx.allocator.alloc(u8, script_name.len + 3);
+    @memcpy(pre_script_name[0..3], "pre");
+    @memcpy(pre_script_name[3..], script_name);
+
+    const post_script_name = try ctx.allocator.alloc(u8, script_name.len + 4);
+    @memcpy(post_script_name[0..4], "post");
+    @memcpy(post_script_name[4..], script_name);
+
+    const fsinstance = try bun.fs.FileSystem.init(null);
+
+    // these things are leaked because we are going to exit
+    var filter_instance = try FilterArg.FilterSet.init(ctx.allocator, ctx.filters, fsinstance.top_level_dir);
+    var patterns = std.ArrayList([]u8).init(ctx.allocator);
+
+    // Find package.json at workspace root
+    var root_buf: bun.PathBuffer = undefined;
+    const resolve_root = try FilterArg.getCandidatePackagePatterns(ctx.allocator, ctx.log, &patterns, fsinstance.top_level_dir, &root_buf);
+
+    var this_bundler: bundler.Bundler = undefined;
+    _ = try RunCommand.configureEnvForRun(ctx, &this_bundler, null, true, false);
+
+    var package_json_iter = try FilterArg.PackageFilterIterator.init(ctx.allocator, patterns.items, resolve_root);
+    defer package_json_iter.deinit();
+
+    // Get list of packages that match the configuration
+    var scripts = std.ArrayList(ScriptConfig).init(ctx.allocator);
+    // var scripts = std.ArrayHashMap([]const u8, ScriptConfig).init(ctx.allocator);
+    while (try package_json_iter.next()) |package_json_path| {
+        const dirpath = std.fs.path.dirname(package_json_path) orelse Global.crash();
+        const path = bun.strings.withoutTrailingSlash(dirpath);
+
+        const pkgjson = bun.PackageJSON.parse(&this_bundler.resolver, dirpath, .zero, null, .include_scripts, .main, .no_hash) orelse {
+            Output.warn("Failed to read package.json\n", .{});
+            continue;
+        };
+
+        const matches = if (filter_instance.has_name_filters)
+            filter_instance.matchesPathName(path, pkgjson.name)
+        else
+            filter_instance.matchesPath(path);
+
+        if (!matches) continue;
+
+        const pkgscripts = pkgjson.scripts orelse continue;
+        const PATH = try RunCommand.configurePathForRunWithPackageJsonDir(ctx, dirpath, &this_bundler, null, dirpath, ctx.debug.run_in_bun);
+
+        for (&[3][]const u8{ pre_script_name, script_name, post_script_name }) |name| {
+            const content = pkgscripts.get(name) orelse continue;
+
+            // we leak this
+            var copy_script = try std.ArrayList(u8).initCapacity(ctx.allocator, content.len);
+            try RunCommand.replacePackageManagerRun(&copy_script, content);
+
+            // and this, too
+            var combined_len = content.len;
+            for (ctx.passthrough) |p| {
+                combined_len += p.len + 1;
+            }
+            var combined = try ctx.allocator.allocSentinel(u8, combined_len, 0);
+            bun.copy(u8, combined, content);
+            var remaining_script_buf = combined[content.len..];
+
+            for (ctx.passthrough) |part| {
+                const p = part;
+                remaining_script_buf[0] = ' ';
+                bun.copy(u8, remaining_script_buf[1..], p);
+                remaining_script_buf = remaining_script_buf[p.len + 1 ..];
+            }
+
+            try scripts.append(.{
+                .package_json_path = try ctx.allocator.dupe(u8, package_json_path),
+                .package_name = pkgjson.name,
+                .script_name = name,
+                .script_content = copy_script.items,
+                .combined = combined,
+                .deps = pkgjson.dependencies,
+                .PATH = PATH,
+            });
+        }
+    }
+
+    if (scripts.items.len == 0) {
+        Output.prettyErrorln("<r><red>error<r>: No packages matched the filter", .{});
+        Global.exit(1);
+    }
+
+    const event_loop = bun.JSC.MiniEventLoop.initGlobal(this_bundler.env);
+    const shell_bin: [:0]const u8 = if (Environment.isPosix)
+        RunCommand.findShell(this_bundler.env.get("PATH") orelse "", fsinstance.top_level_dir) orelse return error.MissingShell
+    else
+        bun.selfExePath() catch return error.MissingShell;
+
+    var state = State{
+        .handles = try ctx.allocator.alloc(ProcessHandle, scripts.items.len),
+        .event_loop = event_loop,
+        .pretty_output = if (Environment.isWindows) windowsIsTerminal() else Output.enable_ansi_colors_stdout,
+        .shell_bin = shell_bin,
+        .env = this_bundler.env,
+    };
+
+    // initialize the handles
+    var map = bun.StringHashMap(std.ArrayList(*ProcessHandle)).init(ctx.allocator);
+    for (scripts.items, 0..) |*script, i| {
+        state.handles[i] = ProcessHandle{
+            .state = &state,
+            .config = script,
+            .options = .{
+                .stdin = .ignore,
+                .stdout = if (Environment.isPosix) .buffer else .{ .buffer = try bun.default_allocator.create(bun.windows.libuv.Pipe) },
+                .stderr = if (Environment.isPosix) .buffer else .{ .buffer = try bun.default_allocator.create(bun.windows.libuv.Pipe) },
+                .cwd = std.fs.path.dirname(script.package_json_path) orelse "",
+                .windows = if (Environment.isWindows) .{ .loop = bun.JSC.EventLoopHandle.init(event_loop) } else {},
+                .stream = true,
+            },
+        };
+        const res = try map.getOrPut(script.package_name);
+        if (res.found_existing) {
+            try res.value_ptr.append(&state.handles[i]);
+            // Output.prettyErrorln("<r><red>error<r>: Duplicate package name: {s}", .{script.package_name});
+            // Global.exit(1);
+        } else {
+            res.value_ptr.* = std.ArrayList(*ProcessHandle).init(ctx.allocator);
+            try res.value_ptr.append(&state.handles[i]);
+            // &state.handles[i];
+        }
+    }
+    // compute dependencies (TODO: maybe we should do this only in a workspace?)
+    for (state.handles) |*handle| {
+        var iter = handle.config.deps.map.iterator();
+        while (iter.next()) |entry| {
+            var alloc = std.heap.stackFallback(256, ctx.allocator);
+            const buf = try alloc.get().alloc(u8, entry.key_ptr.len());
+            defer alloc.get().free(buf);
+            const name = entry.key_ptr.slice(buf);
+            // is it a workspace dependency?
+            if (map.get(name)) |pkgs| {
+                for (pkgs.items) |dep| {
+                    try dep.dependents.append(handle);
+                    handle.remaining_dependencies += 1;
+                }
+            }
+        }
+    }
+
+    // check if there is a dependency cycle
+    var has_cycle = false;
+    for (state.handles) |*handle| {
+        if (hasCycle(handle)) {
+            has_cycle = true;
+            break;
+        }
+    }
+    // if there is, we ignore dependency order completely
+    if (has_cycle) {
+        for (state.handles) |*handle| {
+            handle.dependents.clearRetainingCapacity();
+            handle.remaining_dependencies = 0;
+        }
+    }
+
+    // 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 (0..state.handles.len - 1) |i| {
+        if (bun.strings.eql(state.handles[i].config.package_name, state.handles[i + 1].config.package_name)) {
+            try state.handles[i].dependents.append(&state.handles[i + 1]);
+            state.handles[i + 1].remaining_dependencies += 1;
+        }
+    }
+
+    // start inital scripts
+    for (state.handles) |*handle| {
+        if (handle.remaining_dependencies == 0) {
+            handle.start() catch {
+                // todo this should probably happen in "start"
+                Output.prettyErrorln("<r><red>error<r>: Failed to start process", .{});
+                Global.exit(1);
+            };
+        }
+    }
+
+    AbortHandler.install();
+
+    while (!state.isDone()) {
+        if (AbortHandler.should_abort and !state.aborted) {
+            // We uninstall the custom abort handler so that if the user presses Ctrl+C again,
+            // the process is aborted immediately and doesn't wait for the event loop to tick.
+            // This can be useful if one of the processes is stuck and doesn't react to SIGINT.
+            AbortHandler.uninstall();
+            state.abort();
+        }
+        event_loop.tickOnce(&state);
+    }
+
+    state.finalize();
+
+    Global.exit(0);
+}
+
+fn hasCycle(current: *ProcessHandle) bool {
+    current.visited = true;
+    current.visiting = true;
+    for (current.dependents.items) |dep| {
+        if (dep.visiting) {
+            return true;
+        } else if (!dep.visited) {
+            if (hasCycle(dep)) {
+                return true;
+            }
+        }
+    }
+    current.visiting = false;
+    return false;
+}
diff --git a/src/cli/run_command.zig b/src/cli/run_command.zig
index 6c83424d1cce47..2c3a8d854b284a 100644
--- a/src/cli/run_command.zig
+++ b/src/cli/run_command.zig
@@ -929,23 +929,14 @@ pub const RunCommand = struct {
         return root_dir_info;
     }
 
-    pub fn configurePathForRun(
+    pub fn configurePathForRunWithPackageJsonDir(
         ctx: Command.Context,
-        root_dir_info: *DirInfo,
+        package_json_dir: string,
         this_bundler: *bundler.Bundler,
         ORIGINAL_PATH: ?*string,
         cwd: string,
         force_using_bun: bool,
-    ) !void {
-        var package_json_dir: string = "";
-
-        if (root_dir_info.enclosing_package_json) |package_json| {
-            if (root_dir_info.package_json == null) {
-                // no trailing slash
-                package_json_dir = strings.withoutTrailingSlash(package_json.source.path.name.dir);
-            }
-        }
-
+    ) ![]u8 {
         const PATH = this_bundler.env.get("PATH") orelse "";
         if (ORIGINAL_PATH) |original_path| {
             original_path.* = PATH;
@@ -1015,7 +1006,29 @@ pub const RunCommand = struct {
             try new_path.appendSlice(PATH);
         }
 
-        this_bundler.env.map.put("PATH", new_path.items) catch bun.outOfMemory();
+        return new_path.items;
+    }
+
+    pub fn configurePathForRun(
+        ctx: Command.Context,
+        root_dir_info: *DirInfo,
+        this_bundler: *bundler.Bundler,
+        ORIGINAL_PATH: ?*string,
+        cwd: string,
+        force_using_bun: bool,
+    ) !void {
+        var package_json_dir: string = "";
+
+        if (root_dir_info.enclosing_package_json) |package_json| {
+            if (root_dir_info.package_json == null) {
+                // no trailing slash
+
+                package_json_dir = strings.withoutTrailingSlash(package_json.source.path.name.dir);
+            }
+        }
+
+        const new_path = try configurePathForRunWithPackageJsonDir(ctx, package_json_dir, this_bundler, ORIGINAL_PATH, cwd, force_using_bun);
+        this_bundler.env.map.put("PATH", new_path) catch bun.outOfMemory();
     }
 
     pub fn completions(ctx: Command.Context, default_completions: ?[]const string, reject_list: []const string, comptime filter: Filter) !ShellCompletions {
diff --git a/src/glob.zig b/src/glob.zig
index 524b40c15e45c8..d2ff2b2c605398 100644
--- a/src/glob.zig
+++ b/src/glob.zig
@@ -113,7 +113,7 @@ const CursorState = struct {
     }
 };
 
-pub const BunGlobWalker = GlobWalker_(null, false);
+pub const BunGlobWalker = GlobWalker_(null, SyscallAccessor, false);
 
 fn dummyFilterTrue(val: []const u8) bool {
     _ = val;
@@ -125,11 +125,171 @@ fn dummyFilterFalse(val: []const u8) bool {
     return false;
 }
 
+pub const SyscallAccessor = struct {
+    const count_fds = true;
+
+    const Handle = struct {
+        value: bun.FileDescriptor,
+
+        const zero = Handle{ .value = bun.FileDescriptor.zero };
+
+        pub fn isZero(this: Handle) bool {
+            return this.value == bun.FileDescriptor.zero;
+        }
+
+        pub fn eql(this: Handle, other: Handle) bool {
+            return this.value == other.value;
+        }
+    };
+
+    const DirIter = struct {
+        value: DirIterator.WrappedIterator,
+
+        pub inline fn next(self: *DirIter) Maybe(?DirIterator.IteratorResult) {
+            return self.value.next();
+        }
+
+        pub inline fn iterate(dir: Handle) DirIter {
+            return .{ .value = DirIterator.WrappedIterator.init(dir.value.asDir()) };
+        }
+    };
+
+    pub fn open(path: [:0]const u8) !Maybe(Handle) {
+        return switch (Syscall.open(path, std.os.O.DIRECTORY | std.os.O.RDONLY, 0)) {
+            .err => |err| .{ .err = err },
+            .result => |fd| .{ .result = Handle{ .value = fd } },
+        };
+    }
+
+    pub fn openat(handle: Handle, path: [:0]const u8) !Maybe(Handle) {
+        return switch (Syscall.openat(handle.value, path, std.os.O.DIRECTORY | std.os.O.RDONLY, 0)) {
+            .err => |err| .{ .err = err },
+            .result => |fd| .{ .result = Handle{ .value = fd } },
+        };
+    }
+
+    pub fn close(handle: Handle) ?Syscall.Error {
+        return Syscall.close(handle.value);
+    }
+
+    pub fn getcwd(path_buf: *[bun.MAX_PATH_BYTES]u8) Maybe([]const u8) {
+        return Syscall.getcwd(path_buf);
+    }
+};
+
+pub const DirEntryAccessor = struct {
+    const FS = bun.fs.FileSystem;
+
+    const count_fds = false;
+
+    const Handle = struct {
+        value: ?*FS.DirEntry,
+
+        const zero = Handle{ .value = null };
+
+        pub fn isZero(this: Handle) bool {
+            return this.value == null;
+        }
+
+        pub fn eql(this: Handle, other: Handle) bool {
+            // TODO this might not be quite right, we're comparing pointers, not the underlying directory
+            // On the other hand, DirEntries are only ever created once (per generation), so this should be fine?
+            // Realistically, as closing the handle is a no-op, this should be fine either way.
+            return this.value == other.value;
+        }
+    };
+
+    const DirIter = struct {
+        value: ?FS.DirEntry.EntryMap.Iterator,
+
+        const IterResult = struct {
+            name: NameWrapper,
+            kind: std.fs.File.Kind,
+
+            const NameWrapper = struct {
+                value: []const u8,
+
+                pub fn slice(this: NameWrapper) []const u8 {
+                    return this.value;
+                }
+            };
+        };
+
+        pub inline fn next(self: *DirIter) Maybe(?IterResult) {
+            if (self.value) |*value| {
+                const nextval = value.next() orelse return .{ .result = null };
+                const name = nextval.key_ptr.*;
+                const kind = nextval.value_ptr.*.kind(&FS.instance.fs, true);
+                const fskind = switch (kind) {
+                    .file => std.fs.File.Kind.file,
+                    .dir => std.fs.File.Kind.directory,
+                };
+                return .{
+                    .result = .{
+                        .name = IterResult.NameWrapper{ .value = name },
+                        .kind = fskind,
+                    },
+                };
+            } else {
+                return .{ .result = null };
+            }
+        }
+
+        pub inline fn iterate(dir: Handle) DirIter {
+            const entry = dir.value orelse return DirIter{ .value = null };
+            return .{ .value = entry.data.iterator() };
+        }
+    };
+
+    pub fn open(path: [:0]const u8) !Maybe(Handle) {
+        return openat(Handle.zero, path);
+    }
+
+    pub fn openat(handle: Handle, path_: [:0]const u8) !Maybe(Handle) {
+        var path: []const u8 = path_;
+        var buf: bun.PathBuffer = undefined;
+
+        if (!bun.path.Platform.auto.isAbsolute(path)) {
+            if (handle.value) |entry| {
+                path = bun.path.joinStringBuf(&buf, [_][]const u8{ entry.dir, path }, .auto);
+            }
+        }
+        // TODO do we want to propagate ENOTDIR through the 'Maybe' to match the SyscallAccessor?
+        // The glob implementation specifically checks for this error when dealing with symlinks
+        // return .{ .err = Syscall.Error.fromCode(bun.C.E.NOTDIR, Syscall.Tag.open) };
+        const res = FS.instance.fs.readDirectory(path, null, 0, false) catch |err| {
+            return err;
+        };
+        switch (res.*) {
+            .entries => |entry| {
+                return .{ .result = Handle{ .value = entry } };
+            },
+            .err => |err| {
+                return err.original_err;
+            },
+        }
+    }
+
+    pub inline fn close(handle: Handle) ?Syscall.Error {
+        // TODO is this a noop?
+        _ = handle;
+        return null;
+    }
+
+    pub fn getcwd(path_buf: *[bun.MAX_PATH_BYTES]u8) Maybe([]const u8) {
+        @memcpy(path_buf, bun.fs.FileSystem.instance.fs.cwd);
+    }
+};
+
 pub fn GlobWalker_(
     comptime ignore_filter_fn: ?*const fn ([]const u8) bool,
+    comptime Accessor: type,
     comptime sentinel: bool,
 ) type {
     const is_ignored: *const fn ([]const u8) bool = if (comptime ignore_filter_fn) |func| func else dummyFilterFalse;
+
+    const count_fds = Accessor.count_fds and bun.Environment.allow_assert;
+
     const stdJoin = comptime if (!sentinel) std.fs.path.join else std.fs.path.joinZ;
     const bunJoin = comptime if (!sentinel) ResolvePath.join else ResolvePath.joinZ;
     const MatchedPath = comptime if (!sentinel) []const u8 else [:0]const u8;
@@ -174,8 +334,8 @@ pub fn GlobWalker_(
             directory: Directory,
 
             const Directory = struct {
-                fd: bun.FileDescriptor,
-                iter: DirIterator.WrappedIterator,
+                fd: Accessor.Handle,
+                iter: Accessor.DirIter,
                 path: [bun.MAX_PATH_BYTES]u8,
                 dir_path: [:0]const u8,
 
@@ -192,12 +352,12 @@ pub fn GlobWalker_(
         pub const Iterator = struct {
             walker: *GlobWalker,
             iter_state: IterState = .get_next,
-            cwd_fd: bun.FileDescriptor = .zero,
+            cwd_fd: Accessor.Handle = Accessor.Handle.zero,
             empty_dir_path: [0:0]u8 = [0:0]u8{},
             /// This is to make sure in debug/tests that we are closing file descriptors
             /// We should only have max 2 open at a time. One for the cwd, and one for the
             /// directory being iterated on.
-            fds_open: if (bun.Environment.allow_assert) usize else u0 = 0,
+            fds_open: if (count_fds) usize else u0 = 0,
 
             pub fn init(this: *Iterator) !Maybe(void) {
                 log("Iterator init pattern={s}", .{this.walker.pattern});
@@ -205,13 +365,13 @@ pub fn GlobWalker_(
                 const root_path = this.walker.cwd;
                 @memcpy(path_buf[0..root_path.len], root_path[0..root_path.len]);
                 path_buf[root_path.len] = 0;
-                const root_path_z = path_buf[0..root_path.len :0];
-                const cwd_fd = switch (Syscall.open(root_path_z, std.os.O.DIRECTORY | std.os.O.RDONLY, 0)) {
-                    .err => |err| return .{ .err = this.walker.handleSysErrWithPath(err, root_path_z) },
+                // const root_path_z = path_buf[0..root_path.len :0];
+                const cwd_fd = switch (try Accessor.open(path_buf[0..root_path.len :0])) {
+                    .err => |err| return .{ .err = this.walker.handleSysErrWithPath(err, @ptrCast(path_buf[0 .. root_path.len + 1])) },
                     .result => |fd| fd,
                 };
 
-                if (bun.Environment.allow_assert) {
+                if (comptime count_fds) {
                     this.fds_open += 1;
                 }
 
@@ -243,25 +403,27 @@ pub fn GlobWalker_(
                     }
                 }
 
-                if (bun.Environment.allow_assert) {
-                    bun.assert(this.fds_open == 0);
+                if (comptime count_fds) {
+                    if (bun.Environment.allow_assert) {
+                        bun.assert(this.fds_open == 0);
+                    }
                 }
             }
 
             pub fn closeCwdFd(this: *Iterator) void {
-                if (this.cwd_fd == .zero) return;
-                _ = Syscall.close(this.cwd_fd);
-                if (bun.Environment.allow_assert) this.fds_open -= 1;
+                if (this.cwd_fd.isZero()) return;
+                _ = Accessor.close(this.cwd_fd);
+                if (comptime count_fds) this.fds_open -= 1;
             }
 
-            pub fn closeDisallowingCwd(this: *Iterator, fd: bun.FileDescriptor) void {
-                if (fd == this.cwd_fd or fd == bun.invalid_fd) return;
-                _ = Syscall.close(fd);
-                if (bun.Environment.allow_assert) this.fds_open -= 1;
+            pub fn closeDisallowingCwd(this: *Iterator, fd: Accessor.Handle) void {
+                if (fd.isZero() or fd.eql(this.cwd_fd)) return;
+                _ = Accessor.close(fd);
+                if (comptime count_fds) this.fds_open -= 1;
             }
 
             pub fn bumpOpenFds(this: *Iterator) void {
-                if (bun.Environment.allow_assert) {
+                if (comptime count_fds) {
                     this.fds_open += 1;
                     // If this is over 2 then this means that there is a bug in the iterator code
                     bun.assert(this.fds_open <= 2);
@@ -275,7 +437,7 @@ pub fn GlobWalker_(
             ) !Maybe(void) {
                 log("transition => {s}", .{work_item.path});
                 this.iter_state = .{ .directory = .{
-                    .fd = .zero,
+                    .fd = Accessor.Handle.zero,
                     .iter = undefined,
                     .path = undefined,
                     .dir_path = undefined,
@@ -309,12 +471,12 @@ pub fn GlobWalker_(
                 this.iter_state.directory.next_pattern = if (component_idx + 1 < this.walker.patternComponents.items.len) &this.walker.patternComponents.items[component_idx + 1] else null;
                 this.iter_state.directory.is_last = component_idx == this.walker.patternComponents.items.len - 1;
                 this.iter_state.directory.at_cwd = false;
-                this.iter_state.directory.fd = bun.invalid_fd;
+                this.iter_state.directory.fd = Accessor.Handle.zero;
 
-                const fd: bun.FileDescriptor = fd: {
+                const fd: Accessor.Handle = fd: {
                     if (work_item.fd) |fd| break :fd fd;
                     if (comptime root) {
-                        if (had_dot_dot) break :fd switch (Syscall.openat(this.cwd_fd, dir_path, std.os.O.DIRECTORY | std.os.O.RDONLY, 0)) {
+                        if (had_dot_dot) break :fd switch (try Accessor.openat(this.cwd_fd, dir_path)) {
                             .err => |err| return .{
                                 .err = this.walker.handleSysErrWithPath(err, dir_path),
                             },
@@ -328,7 +490,7 @@ pub fn GlobWalker_(
                         break :fd this.cwd_fd;
                     }
 
-                    break :fd switch (Syscall.openat(this.cwd_fd, dir_path, std.os.O.DIRECTORY | std.os.O.RDONLY, 0)) {
+                    break :fd switch (try Accessor.openat(this.cwd_fd, dir_path)) {
                         .err => |err| return .{
                             .err = this.walker.handleSysErrWithPath(err, dir_path),
                         },
@@ -342,7 +504,7 @@ pub fn GlobWalker_(
                 log("Transition(dirpath={s}, fd={}, component_idx={d})", .{ dir_path, fd, component_idx });
 
                 this.iter_state.directory.fd = fd;
-                const iterator = DirIterator.iterate(fd.asDir(), .u8);
+                const iterator = Accessor.DirIter.iterate(fd);
                 this.iter_state.directory.iter = iterator;
                 this.iter_state.directory.iter_closed = false;
 
@@ -378,7 +540,7 @@ pub fn GlobWalker_(
                                     const is_last = component_idx == this.walker.patternComponents.items.len - 1;
 
                                     this.iter_state = .get_next;
-                                    const maybe_dir_fd: ?bun.FileDescriptor = switch (Syscall.openat(this.cwd_fd, symlink_full_path_z, std.os.O.DIRECTORY | std.os.O.RDONLY, 0)) {
+                                    const maybe_dir_fd: ?Accessor.Handle = switch (try Accessor.openat(this.cwd_fd, symlink_full_path_z)) {
                                         .err => |err| brk: {
                                             if (@as(usize, @intCast(err.errno)) == @as(usize, @intFromEnum(bun.C.E.NOTDIR))) {
                                                 break :brk null;
@@ -546,7 +708,7 @@ pub fn GlobWalker_(
             idx: u32,
             kind: Kind,
             entry_start: u32 = 0,
-            fd: ?bun.FileDescriptor = null,
+            fd: ?Accessor.Handle = null,
 
             const Kind = enum {
                 directory,
@@ -561,7 +723,7 @@ pub fn GlobWalker_(
                 };
             }
 
-            fn newWithFd(path: []const u8, idx: u32, kind: Kind, fd: bun.FileDescriptor) WorkItem {
+            fn newWithFd(path: []const u8, idx: u32, kind: Kind, fd: Accessor.Handle) WorkItem {
                 return .{
                     .path = path,
                     .idx = idx,
@@ -623,7 +785,6 @@ pub fn GlobWalker_(
             error_on_broken_symlinks: bool,
             only_files: bool,
         ) !Maybe(void) {
-            errdefer arena.deinit();
             return try this.initWithCwd(
                 arena,
                 pattern,
@@ -672,26 +833,27 @@ pub fn GlobWalker_(
             error_on_broken_symlinks: bool,
             only_files: bool,
         ) !Maybe(void) {
-            var patternComponents = ArrayList(Component){};
+            this.* = .{
+                .cwd = cwd,
+                .pattern = pattern,
+                .dot = dot,
+                .absolute = absolute,
+                .follow_symlinks = follow_symlinks,
+                .error_on_broken_symlinks = error_on_broken_symlinks,
+                .only_files = only_files,
+            };
+
             try GlobWalker.buildPatternComponents(
                 arena,
-                &patternComponents,
+                &this.patternComponents,
                 pattern,
                 &this.cp_len,
                 &this.pattern_codepoints,
                 &this.has_relative_components,
             );
 
-            this.cwd = cwd;
-
-            this.patternComponents = patternComponents;
-            this.pattern = pattern;
+            // copy arena after all allocations are successful
             this.arena = arena.*;
-            this.dot = dot;
-            this.absolute = absolute;
-            this.follow_symlinks = follow_symlinks;
-            this.error_on_broken_symlinks = error_on_broken_symlinks;
-            this.only_files = only_files;
 
             if (bun.Environment.allow_assert) {
                 this.debugPatternComopnents();
diff --git a/src/json_parser.zig b/src/json_parser.zig
index 4d5dcf770c711a..8110aa3c53753e 100644
--- a/src/json_parser.zig
+++ b/src/json_parser.zig
@@ -506,9 +506,6 @@ pub const PackageJSONVersionChecker = struct {
             },
             else => {
                 try p.lexer.unexpected();
-                if (comptime Environment.isDebug) {
-                    @breakpoint();
-                }
                 return error.ParserError;
             },
         }
diff --git a/src/logger.zig b/src/logger.zig
index a90ad6410432ec..9002e3b09972de 100644
--- a/src/logger.zig
+++ b/src/logger.zig
@@ -1257,6 +1257,14 @@ pub const Log = struct {
         if (needs_newline) _ = try to.write("\n");
     }
 
+    pub fn printForLogLevelColorsRuntime(self: *Log, to: anytype, enable_ansi_colors: bool) !void {
+        if (enable_ansi_colors) {
+            return self.printForLogLevelWithEnableAnsiColors(to, true);
+        } else {
+            return self.printForLogLevelWithEnableAnsiColors(to, false);
+        }
+    }
+
     pub fn toZigException(this: *const Log, allocator: std.mem.Allocator) *js.ZigException.Holder {
         var holder = try allocator.create(js.ZigException.Holder);
         holder.* = js.ZigException.Holder.init();
diff --git a/src/shell/interpreter.zig b/src/shell/interpreter.zig
index ef81a9d9866c6f..0bbc0416ece3b3 100644
--- a/src/shell/interpreter.zig
+++ b/src/shell/interpreter.zig
@@ -50,7 +50,7 @@ const ShellError = shell.ShellError;
 const ast = shell.AST;
 const SmolList = shell.SmolList;
 
-const GlobWalker = @import("../glob.zig").GlobWalker_(null, true);
+const GlobWalker = Glob.GlobWalker_(null, Glob.SyscallAccessor, true);
 
 const stdin_no = 0;
 const stdout_no = 1;
diff --git a/test/cli/run/filter-workspace.test.ts b/test/cli/run/filter-workspace.test.ts
new file mode 100644
index 00000000000000..24aee53e4f821c
--- /dev/null
+++ b/test/cli/run/filter-workspace.test.ts
@@ -0,0 +1,371 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { spawnSync } from "bun";
+import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+import { join } from "path";
+
+const cwd_root = tempDirWithFiles("testworkspace", {
+  packages: {
+    pkga: {
+      "index.js": "console.log('pkga');",
+      "sleep.js":
+        "for (let i = 0; i < 3; i++) { await new Promise(resolve => setTimeout(resolve, 100)); console.log('x'); }",
+      "package.json": JSON.stringify({
+        name: "pkga",
+        scripts: {
+          present: "echo scripta",
+          long: `${bunExe()} run sleep.js`,
+        },
+      }),
+    },
+    pkgb: {
+      "index.js": "console.log('pkgb');",
+      "sleep.js":
+        "for (let i = 0; i < 3; i++) { await new Promise(resolve => setTimeout(resolve, 100)); console.log('y'); }",
+      "package.json": JSON.stringify({
+        name: "pkgb",
+        scripts: {
+          present: "echo scriptb",
+          long: `${bunExe()} run sleep.js`,
+        },
+      }),
+    },
+    dirname: {
+      "index.js": "console.log('pkgc');",
+      "package.json": JSON.stringify({
+        name: "pkgc",
+        scripts: {
+          present: "echo scriptc",
+        },
+      }),
+    },
+    malformed1: {
+      "package.json": JSON.stringify({
+        scripts: {
+          present: "echo malformed1",
+        },
+      }),
+    },
+    malformed2: {
+      "package.json": "asdfsadfas",
+    },
+    missing: {
+      foo: "bar",
+    },
+  },
+  "package.json": JSON.stringify({
+    name: "ws",
+    scripts: {
+      present: "echo rootscript",
+    },
+    workspaces: ["packages/*"],
+  }),
+});
+
+const cwd_packages = join(cwd_root, "packages");
+const cwd_a = join(cwd_packages, "pkga");
+const cwd_b = join(cwd_packages, "pkgb");
+const cwd_c = join(cwd_packages, "dirname");
+
+function runInCwdSuccess({
+  cwd,
+  pattern,
+  target_pattern,
+  antipattern,
+  command = ["present"],
+  auto = false,
+}: {
+  cwd: string;
+  pattern: string | string[];
+  target_pattern: RegExp | RegExp[];
+  antipattern?: RegExp | RegExp[];
+  command?: string[];
+  auto?: boolean;
+}) {
+  const cmd = auto ? [bunExe()] : [bunExe(), "run"];
+  if (Array.isArray(pattern)) {
+    for (const p of pattern) {
+      cmd.push("--filter", p);
+    }
+  } else {
+    cmd.push("--filter", pattern);
+  }
+  for (const c of command) {
+    cmd.push(c);
+  }
+  const { exitCode, stdout, stderr } = spawnSync({
+    cwd: cwd,
+    cmd: cmd,
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const stdoutval = stdout.toString();
+  for (const r of Array.isArray(target_pattern) ? target_pattern : [target_pattern]) {
+    expect(stdoutval).toMatch(r);
+  }
+  if (antipattern !== undefined) {
+    for (const r of Array.isArray(antipattern) ? antipattern : [antipattern]) {
+      expect(stdoutval).not.toMatch(r);
+    }
+  }
+  // expect(stderr.toString()).toBeEmpty();
+  expect(exitCode).toBe(0);
+}
+
+function runInCwdFailure(cwd: string, pkgname: string, scriptname: string, result: RegExp) {
+  const { exitCode, stdout, stderr } = spawnSync({
+    cwd: cwd,
+    cmd: [bunExe(), "run", "--filter", pkgname, scriptname],
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  expect(stdout.toString()).toBeEmpty();
+  expect(stderr.toString()).toMatch(result);
+  expect(exitCode).not.toBe(0);
+}
+
+describe("bun", () => {
+  const dirs = [cwd_root, cwd_packages, cwd_a, cwd_b, cwd_c];
+  const packages = [
+    {
+      name: "pkga",
+      output: /scripta/,
+    },
+    {
+      name: "pkgb",
+      output: /scriptb/,
+    },
+    {
+      name: "pkgc",
+      output: /scriptc/,
+    },
+  ];
+
+  const names = packages.map(p => p.name);
+  for (const d of dirs) {
+    for (const { name, output } of packages) {
+      test(`resolve ${name} from ${d}`, () => {
+        runInCwdSuccess({ cwd: d, pattern: name, target_pattern: output });
+      });
+    }
+  }
+
+  for (const d of dirs) {
+    test(`resolve '*' from ${d}`, () => {
+      runInCwdSuccess({
+        cwd: d,
+        pattern: "*",
+        target_pattern: [/scripta/, /scriptb/, /scriptc/],
+      });
+    });
+    test(`resolve all from ${d}`, () => {
+      runInCwdSuccess({
+        cwd: d,
+        pattern: names,
+        target_pattern: [/scripta/, /scriptb/, /scriptc/],
+      });
+    });
+  }
+
+  test("works with auto command", () => {
+    runInCwdSuccess({
+      cwd: cwd_root,
+      pattern: "./packages/*",
+      target_pattern: [/scripta/, /scriptb/, /scriptc/, /malformed1/],
+      auto: true,
+    });
+  });
+
+  test("resolve all with glob", () => {
+    runInCwdSuccess({
+      cwd: cwd_root,
+      pattern: "./packages/*",
+      target_pattern: [/scripta/, /scriptb/, /scriptc/, /malformed1/],
+    });
+  });
+  test("resolve all with recursive glob", () => {
+    runInCwdSuccess({
+      cwd: cwd_root,
+      pattern: "./**",
+      target_pattern: [/scripta/, /scriptb/, /scriptc/, /malformed1/],
+    });
+  });
+  test("resolve 'pkga' and 'pkgb' but not 'pkgc' with targeted glob", () => {
+    runInCwdSuccess({
+      cwd: cwd_root,
+      pattern: "./packages/pkg*",
+      target_pattern: [/scripta/, /scriptb/],
+      antipattern: /scriptc/,
+    });
+  });
+  test("resolve package with missing name", () => {
+    runInCwdSuccess({
+      cwd: cwd_root,
+      pattern: "./packages/malformed1",
+      target_pattern: [/malformed1/],
+      antipattern: [/scripta/, /scriptb/, /scriptc/],
+    });
+  });
+
+  test("run in parallel", () => {
+    runInCwdSuccess({
+      cwd: cwd_root,
+      pattern: "pkg*",
+      target_pattern: [/x[\s\S]*y[\s\S]*x/],
+      antipattern: [/scripta/, /scriptb/, /scriptc/],
+      command: ["long"],
+    });
+  });
+
+  test("run pre and post scripts, in order", () => {
+    const dir = tempDirWithFiles("testworkspace", {
+      dep0: {
+        "write.js": "await Bun.write('out.txt', 'success')",
+        "readwrite.js": "console.log(await Bun.file('out.txt').text()); await Bun.write('post.txt', 'great success')",
+        "read.js": "console.log(await Bun.file('post.txt').text())",
+        "package.json": JSON.stringify({
+          name: "dep0",
+          scripts: {
+            prescript: `${bunExe()} run write.js`,
+            script: `${bunExe()} run readwrite.js`,
+            postscript: `${bunExe()} run read.js`,
+          },
+        }),
+      },
+    });
+    runInCwdSuccess({
+      cwd: dir,
+      pattern: "*",
+      target_pattern: [/success/, /great success/],
+      antipattern: [/not found/],
+      command: ["script"],
+    });
+  });
+
+  test("respect dependency order", () => {
+    const dir = tempDirWithFiles("testworkspace", {
+      dep0: {
+        "index.js": "Bun.write('out.txt', 'success')",
+        "package.json": JSON.stringify({
+          name: "dep0",
+          scripts: {
+            script: `${bunExe()} run index.js`,
+          },
+        }),
+      },
+      dep1: {
+        "index.js": 'console.log(await Bun.file("../dep0/out.txt").text())',
+        "package.json": JSON.stringify({
+          name: "dep1",
+          dependencies: {
+            dep0: "*",
+          },
+          scripts: {
+            script: `${bunExe()} run index.js`,
+          },
+        }),
+      },
+    });
+    runInCwdSuccess({
+      cwd: dir,
+      pattern: "*",
+      target_pattern: [/success/],
+      antipattern: [/not found/],
+      command: ["script"],
+    });
+  });
+
+  test("ignore dependency order on cycle, preserving pre and post script order", () => {
+    const dir = tempDirWithFiles("testworkspace", {
+      dep0: {
+        "write.js": "await Bun.write('out.txt', 'success')",
+        "readwrite.js":
+          "console.log(await Bun.file('out.txt').text()); await Bun.write('post.txt', 'great success'); setTimeout(() => {}, 300)",
+        "read.js": "console.log(await Bun.file('post.txt').text())",
+        "package.json": JSON.stringify({
+          name: "dep0",
+          scripts: {
+            prescript: `${bunExe()} run write.js`,
+            script: `${bunExe()} run readwrite.js`,
+            postscript: `${bunExe()} run read.js`,
+          },
+          dependencies: {
+            dep1: "*",
+          },
+        }),
+      },
+      dep1: {
+        "index.js": "setTimeout(() => {}, 300)",
+        "package.json": JSON.stringify({
+          name: "dep1",
+          dependencies: {
+            dep0: "*",
+          },
+          scripts: {
+            script: `${bunExe()} run index.js`,
+          },
+        }),
+      },
+    });
+    runInCwdSuccess({
+      cwd: dir,
+      pattern: "*",
+      target_pattern: [/success/, /great success/],
+      antipattern: [/not found/],
+      command: ["script"],
+    });
+  });
+
+  test("detect cycle of length > 2", () => {
+    const dir = tempDirWithFiles("testworkspace", {
+      dep0: {
+        "package.json": JSON.stringify({
+          name: "dep0",
+          scripts: {
+            script: "echo dep0",
+          },
+          dependencies: {
+            dep1: "*",
+          },
+        }),
+      },
+      dep1: {
+        "package.json": JSON.stringify({
+          name: "dep1",
+          dependencies: {
+            dep2: "*",
+          },
+          scripts: {
+            script: "echo dep1",
+          },
+        }),
+      },
+      dep2: {
+        "package.json": JSON.stringify({
+          name: "dep1",
+          dependencies: {
+            dep0: "*",
+          },
+          scripts: {
+            script: "echo dep2",
+          },
+        }),
+      },
+    });
+    runInCwdSuccess({
+      cwd: dir,
+      pattern: "*",
+      target_pattern: [/dep0/, /dep1/, /dep2/],
+      antipattern: [/not found/],
+      command: ["script"],
+    });
+  });
+
+  test("should error with missing script", () => {
+    runInCwdFailure(cwd_root, "*", "notpresent", /No packages matched/);
+  });
+  test("should warn about malformed package.json", () => {
+    runInCwdFailure(cwd_root, "*", "x", /Failed to read package.json/);
+  });
+});
diff --git a/test/harness.ts b/test/harness.ts
index 1f8b7c18a8c0be..8acf65266344cf 100644
--- a/test/harness.ts
+++ b/test/harness.ts
@@ -1,8 +1,9 @@
 import { gc as bunGC, unsafe, which } from "bun";
 import { describe, test, expect, afterAll, beforeAll } from "bun:test";
 import { readlink, readFile, writeFile } from "fs/promises";
-import { isAbsolute, sep, join } from "path";
-import { openSync, closeSync } from "node:fs";
+import { isAbsolute, sep, join, dirname } from "path";
+import fs, { openSync, closeSync } from "node:fs";
+import os from "node:os";
 
 export const isMacOS = process.platform === "darwin";
 export const isLinux = process.platform === "linux";
@@ -110,32 +111,29 @@ export function hideFromStackTrace(block: CallableFunction) {
   });
 }
 
-export function tempDirWithFiles(
-  basename: string,
-  files: Record<string, string | Buffer | Record<string, string | Buffer>>,
-): string {
-  var fs = require("fs");
-  var path = require("path");
-  var { tmpdir } = require("os");
-
-  const dir = fs.mkdtempSync(path.join(fs.realpathSync(tmpdir()), basename + "_"));
-  for (const [name, contents] of Object.entries(files)) {
-    if (typeof contents === "object" && contents && !Buffer.isBuffer(contents)) {
-      const entries = Object.entries(contents);
-      if (entries.length == 0) {
-        fs.mkdirSync(path.join(dir, name), { recursive: true });
-      } else {
-        for (const [_name, _contents] of entries) {
-          fs.mkdirSync(path.dirname(path.join(dir, name, _name)), { recursive: true });
-          fs.writeFileSync(path.join(dir, name, _name), _contents);
-        }
+type DirectoryTree = {
+  [name: string]: string | Buffer | DirectoryTree;
+};
+
+export function tempDirWithFiles(basename: string, files: DirectoryTree): string {
+  function makeTree(base: string, tree: DirectoryTree) {
+    for (const [name, contents] of Object.entries(tree)) {
+      const joined = join(base, name);
+      if (name.includes("/")) {
+        const dir = dirname(name);
+        fs.mkdirSync(join(base, dir), { recursive: true });
+      }
+      if (typeof contents === "object" && contents && !Buffer.isBuffer(contents)) {
+        fs.mkdirSync(joined);
+        makeTree(joined, contents);
+        continue;
       }
-      continue;
+      fs.writeFileSync(joined, contents);
     }
-    fs.mkdirSync(path.dirname(path.join(dir, name)), { recursive: true });
-    fs.writeFileSync(path.join(dir, name), contents);
   }
-  return dir;
+  const base = fs.mkdtempSync(join(fs.realpathSync(os.tmpdir()), basename + "_"));
+  makeTree(base, files);
+  return base;
 }
 
 export function bunRun(file: string, env?: Record<string, string>) {