diff --git a/docs/api/transpiler.md b/docs/api/transpiler.md
index 308a4e152d..d24eb4ac2c 100644
--- a/docs/api/transpiler.md
+++ b/docs/api/transpiler.md
@@ -137,7 +137,8 @@ Each import in the `imports` array has a `path` and `kind`. Bun categories impor
 - `import-rule`: `@import 'foo.css'`
 - `url-token`: `url('./foo.png')`
 <!-- - `internal`: `import {foo} from 'bun:internal'`
-- `entry-point`: `import {foo} from 'bun:entry'` -->
+- `entry-point-build`: `import {foo} from 'bun:entry'`
+- `entry-point-run`: `bun ./mymodule` -->
 
 ## `.scanImports()`
 
@@ -267,7 +268,8 @@ type Import = {
   // The import was injected by Bun
   | "internal" 
   // Entry point (not common)
-  | "entry-point"
+  | "entry-point-build"
+  | "entry-point-run"
 }
 
 const transpiler = new Bun.Transpiler({ loader: "jsx" });
diff --git a/docs/bundler/index.md b/docs/bundler/index.md
index dbb7a95038..8ada85b24c 100644
--- a/docs/bundler/index.md
+++ b/docs/bundler/index.md
@@ -533,7 +533,8 @@ export type BuildManifest = {
 };
 
 export type ImportKind =
-  | "entry-point"
+  | "entry-point-build"
+  | "entry-point-run"
   | "import-statement"
   | "require-call"
   | "dynamic-import"
diff --git a/docs/cli/run.md b/docs/cli/run.md
index b1a7891140..cc4ae91751 100644
--- a/docs/cli/run.md
+++ b/docs/cli/run.md
@@ -106,13 +106,13 @@ $ bun run clean
  Done.
 ```
 
-Bun executes the script command in a subshell. It checks for the following shells in order, using the first one it finds: `bash`, `sh`, `zsh`.
+Bun executes the script command in a subshell. On Linux & macOS, it checks for the following shells in order, using the first one it finds: `bash`, `sh`, `zsh`. On windows, it uses [bun shell](https://bun.sh/docs/runtime/shell) to support bash-like syntax and many common commands.
 
 {% callout %}
 ⚡️ The startup time for `npm run` on Linux is roughly 170ms; with Bun it is `6ms`.
 {% /callout %}
 
-If there is a name conflict between a `package.json` script and a built-in `bun` command (`install`, `dev`, `upgrade`, etc.) Bun's built-in command takes precedence. In this case, use the more explicit `bun run` command to execute your package script.
+Scripts can also be run with the shorter command `bun <script>`, however if there is a built-in bun command with the same name, the built-in command takes precedence. In this case, use the more explicit `bun run <script>` command to execute your package script.
 
 ```bash
 $ bun run dev
@@ -194,3 +194,14 @@ $ bun --smol run index.tsx
 ```
 
 This causes the garbage collector to run more frequently, which can slow down execution. However, it can be useful in environments with limited memory. Bun automatically adjusts the garbage collector's heap size based on the available memory (accounting for cgroups and other memory limits) with and without the `--smol` flag, so this is mostly useful for cases where you want to make the heap size grow more slowly.
+
+## Resolution order
+
+Absolute paths and paths starting with `./` or `.\\` are always executed as source files. Unless using `bun run`, running a file with an allowed extension will prefer the file over a package.json script.
+
+When there is a package.json script and a file with the same name, `bun run` prioritizes the package.json script. The full resolution order is:
+
+1. package.json scripts, eg `bun run build`
+2. Source files, eg `bun run src/main.js`
+3. Binaries from project packages, eg `bun add eslint && bun run eslint`
+4. (`bun run` only) System commands, eg `bun run ls`
diff --git a/packages/bun-polyfills/src/modules/bun/transpiler.ts b/packages/bun-polyfills/src/modules/bun/transpiler.ts
index 670201e2c1..f222376306 100644
--- a/packages/bun-polyfills/src/modules/bun/transpiler.ts
+++ b/packages/bun-polyfills/src/modules/bun/transpiler.ts
@@ -6,14 +6,15 @@ import $ from 'chalk';
 await init();
 
 enum InternalImportKind {
-    'entry-point' = 1, // entry_point
-    'import-statement' = 2, // stmt
-    'require-call' = 3, // require
-    'dynamic-import' = 4, // dynamic
-    'require-resolve' = 5, // require_resolve
-    'import-rule' = 6, // at
-    'url-token' = 7, // url
-    'internal' = 8, // internal
+    'entry-point-run' = 1, // entry_point_run
+    'entry-point-build' = 2, // entry_point_build
+    'import-statement' = 3, // stmt
+    'require-call' = 4, // require
+    'dynamic-import' = 5, // dynamic
+    'require-resolve' = 6, // require_resolve
+    'import-rule' = 7, // at
+    'url-token' = 8, // url
+    'internal' = 9, // internal
 }
 
 export type ScanImportsEntry = {
diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts
index 06df76e2ef..eded771c7b 100644
--- a/packages/bun-types/bun.d.ts
+++ b/packages/bun-types/bun.d.ts
@@ -2278,7 +2278,8 @@ declare module "bun" {
     | "import-rule"
     | "url-token"
     | "internal"
-    | "entry-point";
+    | "entry-point-run"
+    | "entry-point-build";
 
   interface Import {
     path: string;
diff --git a/src/bake/production.zig b/src/bake/production.zig
index 2e95030f94..b7be6033dc 100644
--- a/src/bake/production.zig
+++ b/src/bake/production.zig
@@ -109,7 +109,7 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
         unresolved_config_entry_point = try std.fmt.allocPrint(ctx.allocator, "./{s}", .{unresolved_config_entry_point});
     }
 
-    const config_entry_point = b.resolver.resolve(cwd, unresolved_config_entry_point, .entry_point) catch |err| {
+    const config_entry_point = b.resolver.resolve(cwd, unresolved_config_entry_point, .entry_point_build) catch |err| {
         if (err == error.ModuleNotFound) {
             if (ctx.args.entry_points.len == 0) {
                 // Onboarding message
diff --git a/src/bun.js/bindings/bindings.cpp b/src/bun.js/bindings/bindings.cpp
index 2be795f094..6e9c97c8ba 100644
--- a/src/bun.js/bindings/bindings.cpp
+++ b/src/bun.js/bindings/bindings.cpp
@@ -3266,7 +3266,7 @@ void JSC__JSPromise__resolve(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1,
     ASSERT_WITH_MESSAGE(arg0->inherits<JSC::JSPromise>(), "Argument is not a promise");
     ASSERT_WITH_MESSAGE(arg0->status(arg0->vm()) == JSC::JSPromise::Status::Pending, "Promise is already resolved or rejected");
     ASSERT(!target.isEmpty());
-    ASSERT_WITH_MESSAGE(arg0 != target, "Promise cannot be resoled to itself");
+    ASSERT_WITH_MESSAGE(arg0 != target, "Promise cannot be resolved to itself");
 
     // Note: the Promise can be another promise. Since we go through the generic promise resolve codepath.
     arg0->resolve(arg1, JSC::JSValue::decode(JSValue2));
diff --git a/src/bundler/bundle_v2.zig b/src/bundler/bundle_v2.zig
index 81f3bdc2a1..54abb91627 100644
--- a/src/bundler/bundle_v2.zig
+++ b/src/bundler/bundle_v2.zig
@@ -2029,7 +2029,7 @@ pub const BundleV2 = struct {
                 // When it's not a file, this is an error and we should report it.
                 //
                 // We have no way of loading non-files.
-                if (resolve.import_record.kind == .entry_point or resolve.import_record.importer_source_index == null) {
+                if (resolve.import_record.kind == .entry_point_build or resolve.import_record.importer_source_index == null) {
                     log.addErrorFmt(null, Logger.Loc.Empty, bun.default_allocator, "Module not found {} in namespace {}", .{
                         bun.fmt.quote(resolve.import_record.specifier),
                         bun.fmt.quote(resolve.import_record.namespace),
diff --git a/src/cli.zig b/src/cli.zig
index 19794c7191..baae6a111a 100644
--- a/src/cli.zig
+++ b/src/cli.zig
@@ -1436,8 +1436,6 @@ pub var pretend_to_be_node = false;
 pub var is_bunx_exe = false;
 
 pub const Command = struct {
-    var script_name_buf: bun.PathBuffer = undefined;
-
     pub fn get() Context {
         return global_cli_ctx;
     }
@@ -2148,6 +2146,7 @@ pub const Command = struct {
             .RunCommand => {
                 if (comptime bun.fast_debug_build_mode and bun.fast_debug_build_cmd != .RunCommand) unreachable;
                 const ctx = try Command.init(allocator, log, .RunCommand);
+                ctx.args.target = .bun;
 
                 if (ctx.filters.len > 0) {
                     FilterRun.runScriptsWithFilter(ctx) catch |err| {
@@ -2157,7 +2156,7 @@ pub const Command = struct {
                 }
 
                 if (ctx.positionals.len > 0) {
-                    if (try RunCommand.exec(ctx, false, true, false)) {
+                    if (try RunCommand.exec(ctx, .{ .bin_dirs_only = false, .log_errors = true, .allow_fast_run_for_extensions = false })) {
                         return;
                     }
 
@@ -2190,6 +2189,7 @@ pub const Command = struct {
                         },
                     }
                 };
+                ctx.args.target = .bun;
 
                 if (ctx.filters.len > 0) {
                     FilterRun.runScriptsWithFilter(ctx) catch |err| {
@@ -2240,91 +2240,16 @@ pub const Command = struct {
                     }
                 }
 
-                var was_js_like = false;
-                // If we start bun with:
-                // 1. `bun foo.js`, assume it's a JavaScript file.
-                // 2. `bun /absolute/path/to/bin/foo` assume its a JavaScript file.
-                //                                  ^ no file extension
-                //
-                // #!/usr/bin/env bun
-                // will pass us an absolute path to the script.
-                // This means a non-standard file extension will not work, but that is better than the current state
-                // which is file extension-less doesn't work
-                const default_loader = options.defaultLoaders.get(extension) orelse brk: {
-                    if (extension.len == 0 and ctx.args.entry_points.len > 0 and ctx.args.entry_points[0].len > 0 and std.fs.path.isAbsolute(ctx.args.entry_points[0])) {
-                        break :brk options.Loader.js;
-                    }
-
-                    if (extension.len > 0) {
-                        if (strings.endsWithComptime(ctx.args.entry_points[0], ".sh")) {
-                            break :brk options.Loader.bunsh;
-                        }
-
-                        if (!ctx.debug.loaded_bunfig) {
-                            try bun.CLI.Arguments.loadConfigPath(ctx.allocator, true, "bunfig.toml", ctx, .RunCommand);
-                        }
-
-                        if (ctx.preloads.len > 0)
-                            break :brk options.Loader.js;
-                    }
-
-                    break :brk null;
-                };
-
-                const force_using_bun = ctx.debug.run_in_bun;
-                var did_check = false;
-                if (default_loader) |loader| {
-                    if (loader.canBeRunByBun()) {
-                        was_js_like = true;
-                        if (maybeOpenWithBunJS(ctx)) {
-                            return;
-                        }
-                        did_check = true;
-                    }
-                }
-
-                if (force_using_bun and !did_check) {
-                    if (maybeOpenWithBunJS(ctx)) {
-                        return;
-                    }
-                }
-
-                if (ctx.positionals.len > 0 and extension.len == 0) {
+                if (ctx.positionals.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)) {
+                    if (try RunCommand.exec(ctx, .{ .bin_dirs_only = true, .log_errors = !ctx.runtime_options.if_present, .allow_fast_run_for_extensions = true })) {
                         return;
                     }
-
-                    Output.prettyErrorln("<r><red>error<r><d>:<r> <b>Script not found \"{s}\"<r>", .{
-                        ctx.positionals[0],
-                    });
-
-                    Global.exit(1);
-                }
-
-                if (ctx.runtime_options.if_present) {
                     return;
                 }
 
-                if (was_js_like) {
-                    Output.prettyErrorln("<r><red>error<r><d>:<r> <b>Module not found \"{s}\"<r>", .{
-                        ctx.positionals[0],
-                    });
-                    Global.exit(1);
-                } else if (ctx.positionals.len > 0) {
-                    Output.prettyErrorln("<r><red>error<r><d>:<r> <b>File not found: \"{s}\"<r>", .{
-                        ctx.positionals[0],
-                    });
-                    Global.exit(1);
-                }
-
-                // if we get here, the command was not parsed
-                // or the user just ran `bun` with no arguments
-                if (ctx.positionals.len > 0) {
-                    Output.warn("failed to parse command\n", .{});
-                }
                 Output.flush();
                 try HelpCommand.exec(allocator);
             },
@@ -2338,94 +2263,6 @@ pub const Command = struct {
         }
     }
 
-    fn maybeOpenWithBunJS(ctx: Command.Context) bool {
-        if (ctx.args.entry_points.len == 0)
-            return false;
-
-        const script_name_to_search = ctx.args.entry_points[0];
-
-        var absolute_script_path: ?string = null;
-
-        // TODO: optimize this pass for Windows. we can make better use of system apis available
-        var file_path = script_name_to_search;
-        {
-            const file = bun.toLibUVOwnedFD(((brk: {
-                if (std.fs.path.isAbsolute(script_name_to_search)) {
-                    var win_resolver = resolve_path.PosixToWinNormalizer{};
-                    var resolved = win_resolver.resolveCWD(script_name_to_search) catch @panic("Could not resolve path");
-                    if (comptime Environment.isWindows) {
-                        resolved = resolve_path.normalizeString(resolved, false, .windows);
-                    }
-                    break :brk bun.openFile(
-                        resolved,
-                        .{ .mode = .read_only },
-                    );
-                } else if (!strings.hasPrefix(script_name_to_search, "..") and script_name_to_search[0] != '~') {
-                    const file_pathZ = brk2: {
-                        @memcpy(script_name_buf[0..file_path.len], file_path);
-                        script_name_buf[file_path.len] = 0;
-                        break :brk2 script_name_buf[0..file_path.len :0];
-                    };
-
-                    break :brk bun.openFileZ(file_pathZ, .{ .mode = .read_only });
-                } else {
-                    var path_buf: bun.PathBuffer = undefined;
-                    const cwd = bun.getcwd(&path_buf) catch return false;
-                    path_buf[cwd.len] = std.fs.path.sep;
-                    var parts = [_]string{script_name_to_search};
-                    file_path = resolve_path.joinAbsStringBuf(
-                        path_buf[0 .. cwd.len + 1],
-                        &script_name_buf,
-                        &parts,
-                        .auto,
-                    );
-                    if (file_path.len == 0) return false;
-                    script_name_buf[file_path.len] = 0;
-                    const file_pathZ = script_name_buf[0..file_path.len :0];
-                    break :brk bun.openFileZ(file_pathZ, .{ .mode = .read_only });
-                }
-            }) catch return false).handle) catch return false;
-            defer _ = bun.sys.close(file);
-
-            switch (bun.sys.fstat(file)) {
-                .result => |stat| {
-                    // directories cannot be run. if only there was a faster way to check this
-                    if (bun.S.ISDIR(@intCast(stat.mode))) return false;
-                },
-                .err => return false,
-            }
-
-            Global.configureAllocator(.{ .long_running = true });
-
-            absolute_script_path = brk: {
-                if (comptime !Environment.isWindows) break :brk bun.getFdPath(file, &script_name_buf) catch return false;
-
-                var fd_path_buf: bun.PathBuffer = undefined;
-                break :brk bun.getFdPath(file, &fd_path_buf) catch return false;
-            };
-        }
-
-        if (!ctx.debug.loaded_bunfig) {
-            bun.CLI.Arguments.loadConfigPath(ctx.allocator, true, "bunfig.toml", ctx, .RunCommand) catch {};
-        }
-
-        BunJS.Run.boot(
-            ctx,
-            absolute_script_path.?,
-        ) catch |err| {
-            bun.handleErrorReturnTrace(err, @errorReturnTrace());
-
-            ctx.log.print(Output.errorWriter()) catch {};
-
-            Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
-                std.fs.path.basename(file_path),
-                @errorName(err),
-            });
-            Global.exit(1);
-        };
-        return true;
-    }
-
     pub const Tag = enum {
         AddCommand,
         AutoCommand,
diff --git a/src/cli/exec_command.zig b/src/cli/exec_command.zig
index 58a0b757eb..13a76166c4 100644
--- a/src/cli/exec_command.zig
+++ b/src/cli/exec_command.zig
@@ -39,7 +39,7 @@ pub const ExecCommand = struct {
         };
         const script_path = bun.path.join(parts, .auto);
 
-        const code = bun.shell.Interpreter.initAndRunFromSource(ctx, mini, script_path, script) catch |err| {
+        const code = bun.shell.Interpreter.initAndRunFromSource(ctx, mini, script_path, script, null) catch |err| {
             Output.err(err, "failed to run script <b>{s}<r>", .{script_path});
             Global.exit(1);
         };
diff --git a/src/cli/run_command.zig b/src/cli/run_command.zig
index 78fbbf3c7e..f0343fa121 100644
--- a/src/cli/run_command.zig
+++ b/src/cli/run_command.zig
@@ -301,7 +301,7 @@ pub const RunCommand = struct {
 
         if (!use_system_shell) {
             const mini = bun.JSC.MiniEventLoop.initGlobal(env);
-            const code = bun.shell.Interpreter.initAndRunFromSource(ctx, mini, name, copy_script.items) catch |err| {
+            const code = bun.shell.Interpreter.initAndRunFromSource(ctx, mini, name, copy_script.items, cwd) catch |err| {
                 if (!silent) {
                     Output.prettyErrorln("<r><red>error<r>: Failed to run script <b>{s}<r> due to error <b>{s}<r>", .{ name, @errorName(err) });
                 }
@@ -819,8 +819,8 @@ pub const RunCommand = struct {
         this_transpiler.resolver.care_about_scripts = true;
         this_transpiler.resolver.store_fd = store_root_fd;
 
-        this_transpiler.resolver.opts.load_tsconfig_json = false;
-        this_transpiler.options.load_tsconfig_json = false;
+        this_transpiler.resolver.opts.load_tsconfig_json = true;
+        this_transpiler.options.load_tsconfig_json = true;
 
         this_transpiler.configureLinker();
 
@@ -1262,153 +1262,155 @@ pub const RunCommand = struct {
         Output.flush();
     }
 
+    fn _bootAndHandleError(ctx: Command.Context, path: string) bool {
+        Global.configureAllocator(.{ .long_running = true });
+        Run.boot(ctx, ctx.allocator.dupe(u8, path) catch return false) catch |err| {
+            ctx.log.print(Output.errorWriter()) catch {};
+
+            Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
+                std.fs.path.basename(path),
+                @errorName(err),
+            });
+            bun.handleErrorReturnTrace(err, @errorReturnTrace());
+            Global.exit(1);
+        };
+        return true;
+    }
+    fn maybeOpenWithBunJS(ctx: Command.Context) bool {
+        if (ctx.args.entry_points.len == 0)
+            return false;
+        var script_name_buf: bun.PathBuffer = undefined;
+
+        const script_name_to_search = ctx.args.entry_points[0];
+
+        var absolute_script_path: ?string = null;
+
+        // TODO: optimize this pass for Windows. we can make better use of system apis available
+        var file_path = script_name_to_search;
+        {
+            const file = bun.toLibUVOwnedFD(((brk: {
+                if (std.fs.path.isAbsolute(script_name_to_search)) {
+                    var win_resolver = resolve_path.PosixToWinNormalizer{};
+                    var resolved = win_resolver.resolveCWD(script_name_to_search) catch @panic("Could not resolve path");
+                    if (comptime Environment.isWindows) {
+                        resolved = resolve_path.normalizeString(resolved, false, .windows);
+                    }
+                    break :brk bun.openFile(
+                        resolved,
+                        .{ .mode = .read_only },
+                    );
+                } else if (!strings.hasPrefix(script_name_to_search, "..") and script_name_to_search[0] != '~') {
+                    const file_pathZ = brk2: {
+                        @memcpy(script_name_buf[0..file_path.len], file_path);
+                        script_name_buf[file_path.len] = 0;
+                        break :brk2 script_name_buf[0..file_path.len :0];
+                    };
+
+                    break :brk bun.openFileZ(file_pathZ, .{ .mode = .read_only });
+                } else {
+                    var path_buf_2: bun.PathBuffer = undefined;
+                    const cwd = bun.getcwd(&path_buf_2) catch return false;
+                    path_buf_2[cwd.len] = std.fs.path.sep;
+                    var parts = [_]string{script_name_to_search};
+                    file_path = resolve_path.joinAbsStringBuf(
+                        path_buf_2[0 .. cwd.len + 1],
+                        &script_name_buf,
+                        &parts,
+                        .auto,
+                    );
+                    if (file_path.len == 0) return false;
+                    script_name_buf[file_path.len] = 0;
+                    const file_pathZ = script_name_buf[0..file_path.len :0];
+                    break :brk bun.openFileZ(file_pathZ, .{ .mode = .read_only });
+                }
+            }) catch return false).handle) catch return false;
+            defer _ = bun.sys.close(file);
+
+            switch (bun.sys.fstat(file)) {
+                .result => |stat| {
+                    // directories cannot be run. if only there was a faster way to check this
+                    if (bun.S.ISDIR(@intCast(stat.mode))) return false;
+                },
+                .err => return false,
+            }
+
+            Global.configureAllocator(.{ .long_running = true });
+
+            absolute_script_path = brk: {
+                if (comptime !Environment.isWindows) break :brk bun.getFdPath(file, &script_name_buf) catch return false;
+
+                var fd_path_buf: bun.PathBuffer = undefined;
+                break :brk bun.getFdPath(file, &fd_path_buf) catch return false;
+            };
+        }
+
+        if (!ctx.debug.loaded_bunfig) {
+            bun.CLI.Arguments.loadConfigPath(ctx.allocator, true, "bunfig.toml", ctx, .RunCommand) catch {};
+        }
+
+        _ = _bootAndHandleError(ctx, absolute_script_path.?);
+        return true;
+    }
     pub fn exec(
         ctx: Command.Context,
-        comptime bin_dirs_only: bool,
-        comptime log_errors: bool,
-        comptime did_try_open_with_bun_js: bool,
+        cfg: struct {
+            bin_dirs_only: bool,
+            log_errors: bool,
+            allow_fast_run_for_extensions: bool,
+        },
     ) !bool {
-        // Step 1. Figure out what we're trying to run
+        const bin_dirs_only = cfg.bin_dirs_only;
+        const log_errors = cfg.log_errors;
+
+        // find what to run
+
         var positionals = ctx.positionals;
-        if (positionals.len > 0 and strings.eqlComptime(positionals[0], "run") or strings.eqlComptime(positionals[0], "r")) {
+        if (positionals.len > 0 and strings.eqlComptime(positionals[0], "run")) {
             positionals = positionals[1..];
         }
 
-        var script_name_to_search: string = "";
-
+        var target_name: string = "";
         if (positionals.len > 0) {
-            script_name_to_search = positionals[0];
+            target_name = positionals[0];
+            positionals = positionals[1..];
         }
+        const passthrough = ctx.passthrough; // unclear why passthrough is an escaped string, it should probably be []const []const u8 and allow its users to escape it.
 
-        const passthrough = ctx.passthrough;
-        const force_using_bun = ctx.debug.run_in_bun;
-
-        // This doesn't cover every case
-        if ((script_name_to_search.len == 1 and script_name_to_search[0] == '.') or
-            (script_name_to_search.len == 2 and @as(u16, @bitCast(script_name_to_search[0..2].*)) == @as(u16, @bitCast([_]u8{ '.', '/' }))))
-        {
-            Run.boot(ctx, ".") catch |err| {
-                bun.handleErrorReturnTrace(err, @errorReturnTrace());
-
-                ctx.log.print(Output.errorWriter()) catch {};
-
-                Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
-                    script_name_to_search,
-                    @errorName(err),
-                });
-                Global.exit(1);
-            };
-            return true;
-        }
-
-        if (!did_try_open_with_bun_js and (log_errors or force_using_bun)) {
-            if (script_name_to_search.len > 0) {
-                possibly_open_with_bun_js: {
-                    const ext = std.fs.path.extension(script_name_to_search);
-                    var has_loader = false;
-                    if (!force_using_bun) {
-                        if (options.defaultLoaders.get(ext)) |load| {
-                            has_loader = true;
-                            if (!load.canBeRunByBun())
-                                break :possibly_open_with_bun_js;
-                            // if there are preloads, allow weirdo file extensions
-                        } else {
-                            // you can have package.json scripts with file extensions in the name
-                            // eg "foo.zip"
-                            // in those cases, we don't know
-                            if (ext.len == 0 or strings.containsChar(script_name_to_search, ':'))
-                                break :possibly_open_with_bun_js;
-                        }
-                    }
-
-                    var file_path = script_name_to_search;
-                    const file_: anyerror!std.fs.File = brk: {
-                        if (std.fs.path.isAbsolute(script_name_to_search)) {
-                            var resolver = resolve_path.PosixToWinNormalizer{};
-                            break :brk bun.openFile(try resolver.resolveCWD(script_name_to_search), .{ .mode = .read_only });
-                        } else {
-                            const cwd = bun.getcwd(&path_buf) catch break :possibly_open_with_bun_js;
-                            path_buf[cwd.len] = std.fs.path.sep_posix;
-                            var parts = [_]string{script_name_to_search};
-                            file_path = resolve_path.joinAbsStringBuf(
-                                path_buf[0 .. cwd.len + 1],
-                                &path_buf2,
-                                &parts,
-                                .auto,
-                            );
-                            if (file_path.len == 0) break :possibly_open_with_bun_js;
-                            path_buf2[file_path.len] = 0;
-                            const file_pathZ = path_buf2[0..file_path.len :0];
-                            break :brk bun.openFileZ(file_pathZ, .{ .mode = .read_only });
-                        }
-                    };
-
-                    const file = file_ catch break :possibly_open_with_bun_js;
-
-                    if (!force_using_bun) {
-                        // Due to preload, we don't know if they intend to run
-                        // this as a script or as a regular file
-                        // once we know it's a file, check if they have any preloads
-                        if (ext.len > 0 and !has_loader) {
-                            if (!ctx.debug.loaded_bunfig) {
-                                try CLI.Arguments.loadConfigPath(ctx.allocator, true, "bunfig.toml", ctx, .RunCommand);
-                            }
-
-                            if (ctx.preloads.len == 0)
-                                break :possibly_open_with_bun_js;
-                        }
-
-                        // ignore the shebang if they explicitly passed `--bun`
-                        // "White space after #! is optional."
-                        var shebang_buf: [64]u8 = undefined;
-                        const shebang_size = file.pread(&shebang_buf, 0) catch |err| {
-                            if (!ctx.debug.silent)
-                                Output.prettyErrorln("<r><red>error<r>: Failed to read file <b>{s}<r> due to error <b>{s}<r>", .{ file_path, @errorName(err) });
-                            Global.exit(1);
-                        };
-
-                        var shebang: string = shebang_buf[0..shebang_size];
-
-                        shebang = std.mem.trim(u8, shebang, " \r\n\t");
-                        if (strings.hasPrefixComptime(shebang, "#!")) {
-                            const first_arg: string = if (bun.argv.len > 0) bun.argv[0] else "";
-                            const filename = std.fs.path.basename(first_arg);
-                            // are we attempting to run the script with bun?
-                            if (!strings.contains(shebang, filename)) {
-                                break :possibly_open_with_bun_js;
-                            }
-                        }
-                    }
-
-                    Global.configureAllocator(.{ .long_running = true });
-                    const out_path = ctx.allocator.dupe(u8, file_path) catch unreachable;
-                    Run.boot(ctx, out_path) catch |err| {
-                        bun.handleErrorReturnTrace(err, @errorReturnTrace());
-
-                        ctx.log.print(Output.errorWriter()) catch {};
-
-                        Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
-                            std.fs.path.basename(file_path),
-                            @errorName(err),
-                        });
-                        Global.exit(1);
-                    };
-
-                    return true;
-                }
+        var try_fast_run = false;
+        var skip_script_check = false;
+        if (target_name.len > 0 and target_name[0] == '.') {
+            try_fast_run = true;
+            skip_script_check = true;
+        } else if (std.fs.path.isAbsolute(target_name)) {
+            try_fast_run = true;
+            skip_script_check = true;
+        } else if (cfg.allow_fast_run_for_extensions) {
+            const ext = std.fs.path.extension(target_name);
+            const default_loader = options.defaultLoaders.get(ext);
+            if (default_loader != null and default_loader.?.canBeRunByBun()) {
+                try_fast_run = true;
             }
         }
 
-        Global.configureAllocator(.{ .long_running = false });
+        // try fast run (check if the file exists and is not a folder, then run it)
+        if (try_fast_run and maybeOpenWithBunJS(ctx)) return true;
 
+        // setup
+
+        const force_using_bun = ctx.debug.run_in_bun;
         var ORIGINAL_PATH: string = "";
         var this_transpiler: transpiler.Transpiler = undefined;
         const root_dir_info = try configureEnvForRun(ctx, &this_transpiler, null, log_errors, false);
         try configurePathForRun(ctx, root_dir_info, &this_transpiler, &ORIGINAL_PATH, root_dir_info.abs_path, force_using_bun);
         this_transpiler.env.map.put("npm_command", "run-script") catch unreachable;
 
-        if (script_name_to_search.len == 0) {
-            // naked "bun run"
+        if (!ctx.debug.loaded_bunfig) {
+            bun.CLI.Arguments.loadConfigPath(ctx.allocator, true, "bunfig.toml", ctx, .RunCommand) catch {};
+        }
+
+        // check for empty command
+
+        if (target_name.len == 0) {
             if (root_dir_info.enclosing_package_json) |package_json| {
                 RunCommand.printHelp(package_json);
             } else {
@@ -1420,81 +1422,11 @@ pub const RunCommand = struct {
             return true;
         }
 
-        // Run package.json script
-        if (root_dir_info.enclosing_package_json) |package_json| {
-            if (package_json.scripts) |scripts| {
-                if (scripts.get(script_name_to_search)) |script_content| {
-                    // allocate enough to hold "post${scriptname}"
-                    var temp_script_buffer = try std.fmt.allocPrint(ctx.allocator, "ppre{s}", .{script_name_to_search});
-                    defer ctx.allocator.free(temp_script_buffer);
+        // check for stdin
 
-                    if (scripts.get(temp_script_buffer[1..])) |prescript| {
-                        try runPackageScriptForeground(
-                            ctx,
-                            ctx.allocator,
-                            prescript,
-                            temp_script_buffer[1..],
-                            this_transpiler.fs.top_level_dir,
-                            this_transpiler.env,
-                            &.{},
-                            ctx.debug.silent,
-                            ctx.debug.use_system_shell,
-                        );
-                    }
+        if (target_name.len == 1 and target_name[0] == '-') {
+            log("Executing from stdin", .{});
 
-                    {
-                        try runPackageScriptForeground(
-                            ctx,
-                            ctx.allocator,
-                            script_content,
-                            script_name_to_search,
-                            this_transpiler.fs.top_level_dir,
-                            this_transpiler.env,
-                            passthrough,
-                            ctx.debug.silent,
-                            ctx.debug.use_system_shell,
-                        );
-                    }
-
-                    temp_script_buffer[0.."post".len].* = "post".*;
-
-                    if (scripts.get(temp_script_buffer)) |postscript| {
-                        try runPackageScriptForeground(
-                            ctx,
-                            ctx.allocator,
-                            postscript,
-                            temp_script_buffer,
-                            this_transpiler.fs.top_level_dir,
-                            this_transpiler.env,
-                            &.{},
-                            ctx.debug.silent,
-                            ctx.debug.use_system_shell,
-                        );
-                    }
-
-                    return true;
-                }
-            }
-        }
-
-        // Run absolute/relative path
-        if (std.fs.path.isAbsolute(script_name_to_search) or
-            (script_name_to_search.len > 2 and script_name_to_search[0] == '.' and script_name_to_search[1] == '/'))
-        {
-            Run.boot(ctx, ctx.allocator.dupe(u8, script_name_to_search) catch unreachable) catch |err| {
-                bun.handleErrorReturnTrace(err, @errorReturnTrace());
-
-                ctx.log.print(Output.errorWriter()) catch {};
-
-                Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
-                    std.fs.path.basename(script_name_to_search),
-                    @errorName(err),
-                });
-                Global.exit(1);
-            };
-        }
-
-        if (script_name_to_search.len == 1 and script_name_to_search[0] == '-') {
             // read from stdin
             var stack_fallback = std.heap.stackFallback(2048, bun.default_allocator);
             var list = std.ArrayList(u8).init(stack_fallback.get());
@@ -1513,7 +1445,7 @@ pub const RunCommand = struct {
                 ctx.log.print(Output.errorWriter()) catch {};
 
                 Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
-                    std.fs.path.basename(script_name_to_search),
+                    std.fs.path.basename(target_name),
                     @errorName(err),
                 });
                 bun.handleErrorReturnTrace(err, @errorReturnTrace());
@@ -1522,6 +1454,86 @@ pub const RunCommand = struct {
             return true;
         }
 
+        // run script with matching name
+
+        if (!skip_script_check) if (root_dir_info.enclosing_package_json) |package_json| {
+            if (package_json.scripts) |scripts| {
+                if (scripts.get(target_name)) |script_content| {
+                    log("Found matching script `{s}`", .{script_content});
+                    Global.configureAllocator(.{ .long_running = false });
+                    this_transpiler.env.map.put("npm_lifecycle_event", target_name) catch unreachable;
+
+                    // allocate enough to hold "post${scriptname}"
+                    var temp_script_buffer = try std.fmt.allocPrint(ctx.allocator, "\x00pre{s}", .{target_name});
+                    defer ctx.allocator.free(temp_script_buffer);
+
+                    const package_json_path = root_dir_info.enclosing_package_json.?.source.path.text;
+                    const package_json_dir = strings.withoutTrailingSlash(strings.withoutSuffixComptime(package_json_path, "package.json"));
+                    log("Running in dir `{s}`", .{package_json_dir});
+
+                    if (scripts.get(temp_script_buffer[1..])) |prescript| {
+                        try runPackageScriptForeground(
+                            ctx,
+                            ctx.allocator,
+                            prescript,
+                            temp_script_buffer[1..],
+                            package_json_dir,
+                            this_transpiler.env,
+                            &.{},
+                            ctx.debug.silent,
+                            ctx.debug.use_system_shell,
+                        );
+                    }
+
+                    try runPackageScriptForeground(
+                        ctx,
+                        ctx.allocator,
+                        script_content,
+                        target_name,
+                        package_json_dir,
+                        this_transpiler.env,
+                        passthrough,
+                        ctx.debug.silent,
+                        ctx.debug.use_system_shell,
+                    );
+
+                    temp_script_buffer[0.."post".len].* = "post".*;
+
+                    if (scripts.get(temp_script_buffer)) |postscript| {
+                        try runPackageScriptForeground(
+                            ctx,
+                            ctx.allocator,
+                            postscript,
+                            temp_script_buffer,
+                            package_json_dir,
+                            this_transpiler.env,
+                            &.{},
+                            ctx.debug.silent,
+                            ctx.debug.use_system_shell,
+                        );
+                    }
+
+                    return true;
+                }
+            }
+        };
+
+        // load module and run that module
+        // TODO: run module resolution here - try the next condition if the module can't be found
+
+        log("Try resolve `{s}` in `{s}`", .{ target_name, this_transpiler.fs.top_level_dir });
+        if (this_transpiler.resolver.resolve(this_transpiler.fs.top_level_dir, target_name, .entry_point_run)) |resolved| {
+            var resolved_mutable = resolved;
+            log("Resolved to: `{s}`", .{resolved_mutable.path().?.text});
+            return _bootAndHandleError(ctx, resolved_mutable.path().?.text);
+        } else |_| if (this_transpiler.resolver.resolve(this_transpiler.fs.top_level_dir, try std.mem.join(ctx.allocator, "", &.{ "./", target_name }), .entry_point_run)) |resolved| {
+            var resolved_mutable = resolved;
+            log("Resolved with `./` to: `{s}`", .{resolved_mutable.path().?.text});
+            return _bootAndHandleError(ctx, resolved_mutable.path().?.text);
+        } else |_| {}
+
+        // execute a node_modules/.bin/<X> command, or (run only) a system command like 'ls'
+
         if (Environment.isWindows and bun.FeatureFlags.windows_bunx_fast_path) try_bunx_file: {
             // Attempt to find a ".bunx" file on disk, and run it, skipping the
             // wrapper exe.  we build the full exe path even though we could do
@@ -1540,13 +1552,13 @@ pub const RunCommand = struct {
             const prefix = comptime bun.strings.w("\\node_modules\\.bin\\");
             @memcpy(ptr[0..prefix.len], prefix);
             ptr = ptr[prefix.len..];
-            const encoded = bun.strings.convertUTF8toUTF16InBuffer(ptr[0..], script_name_to_search);
+            const encoded = bun.strings.convertUTF8toUTF16InBuffer(ptr[0..], target_name);
             ptr = ptr[encoded.len..];
             const ext = comptime bun.strings.w(".bunx");
             @memcpy(ptr[0..ext.len], ext);
             ptr[ext.len] = 0;
 
-            const l = root.len + cwd_len + prefix.len + script_name_to_search.len + ext.len;
+            const l = root.len + cwd_len + prefix.len + target_name.len + ext.len;
             const path_to_use = BunXFastPath.direct_launch_buffer[0..l :0];
             BunXFastPath.tryLaunch(ctx, path_to_use, this_transpiler.env, ctx.passthrough);
         }
@@ -1562,7 +1574,7 @@ pub const RunCommand = struct {
         }
 
         if (path_for_which.len > 0) {
-            if (which(&path_buf, path_for_which, this_transpiler.fs.top_level_dir, script_name_to_search)) |destination| {
+            if (which(&path_buf, path_for_which, this_transpiler.fs.top_level_dir, target_name)) |destination| {
                 const out = bun.asByteSlice(destination);
                 return try runBinaryWithoutBunxPath(
                     ctx,
@@ -1571,17 +1583,28 @@ pub const RunCommand = struct {
                     this_transpiler.fs.top_level_dir,
                     this_transpiler.env,
                     passthrough,
-                    script_name_to_search,
+                    target_name,
                 );
             }
         }
 
+        // failure
+
         if (ctx.runtime_options.if_present) {
             return true;
         }
 
         if (comptime log_errors) {
-            Output.prettyError("<r><red>error<r><d>:<r> <b>Script not found \"<b>{s}<r>\"\n", .{script_name_to_search});
+            const ext = std.fs.path.extension(target_name);
+            const default_loader = options.defaultLoaders.get(ext);
+            if (default_loader != null and default_loader.?.isJavaScriptLikeOrJSON() or target_name.len > 0 and (target_name[0] == '.' or target_name[0] == '/' or std.fs.path.isAbsolute(target_name))) {
+                Output.prettyError("<r><red>error<r><d>:<r> <b>Module not found \"<b>{s}<r>\"\n", .{target_name});
+            } else if (ext.len > 0) {
+                Output.prettyError("<r><red>error<r><d>:<r> <b>File not found \"<b>{s}<r>\"\n", .{target_name});
+            } else {
+                Output.prettyError("<r><red>error<r><d>:<r> <b>Script not found \"<b>{s}<r>\"\n", .{target_name});
+            }
+
             Global.exit(1);
         }
 
diff --git a/src/codegen/replacements.ts b/src/codegen/replacements.ts
index 103ba1b8b0..148291b317 100644
--- a/src/codegen/replacements.ts
+++ b/src/codegen/replacements.ts
@@ -93,7 +93,8 @@ replacements.push({
 export const enums = {
   Loader: LoaderKeys,
   ImportKind: [
-    "entry-point",
+    "entry-point-run",
+    "entry-point-build",
     "import-statement",
     "require-call",
     "dynamic-import",
diff --git a/src/css/targets.zig b/src/css/targets.zig
index c5fe76f214..26f744bc39 100644
--- a/src/css/targets.zig
+++ b/src/css/targets.zig
@@ -58,11 +58,10 @@ pub const Targets = struct {
         return this.include.contains(flag) or (!this.exclude.contains(flag) and !this.isCompatible(feature));
     }
 
-    pub fn shouldCompileSame(this: *const Targets, comptime prop: @Type(.EnumLiteral)) bool {
-        const compat_feature: css.compat.Feature = prop;
+    pub fn shouldCompileSame(this: *const Targets, comptime compat_feature: css.compat.Feature) bool {
         const target_feature: css.targets.Features = target_feature: {
             var feature: css.targets.Features = .{};
-            @field(feature, @tagName(prop)) = true;
+            @field(feature, @tagName(compat_feature)) = true;
             break :target_feature feature;
         };
 
diff --git a/src/import_record.zig b/src/import_record.zig
index 87d1f93ac5..a81f5f180b 100644
--- a/src/import_record.zig
+++ b/src/import_record.zig
@@ -7,24 +7,26 @@ const Index = @import("ast/base.zig").Index;
 const Api = @import("./api/schema.zig").Api;
 
 pub const ImportKind = enum(u8) {
-    /// An entry point provided by the user
-    entry_point,
+    /// An entry point provided to `bun run` or `bun`
+    entry_point_run = 0,
+    /// An entry point provided to `bun build` or `Bun.build`
+    entry_point_build = 1,
     /// An ES6 import or re-export statement
-    stmt,
+    stmt = 2,
     /// A call to "require()"
-    require,
+    require = 3,
     /// An "import()" expression with a string argument
-    dynamic,
+    dynamic = 4,
     /// A call to "require.resolve()"
-    require_resolve,
+    require_resolve = 5,
     /// A CSS "@import" rule
-    at,
+    at = 6,
     /// A CSS "@import" rule with import conditions
-    at_conditional,
+    at_conditional = 7,
     /// A CSS "url(...)" token
-    url,
+    url = 8,
 
-    internal,
+    internal = 9,
 
     pub const Label = std.EnumArray(ImportKind, []const u8);
     pub const all_labels: Label = brk: {
@@ -32,7 +34,8 @@ pub const ImportKind = enum(u8) {
         // - src/js/builtins/codegen/replacements.ts
         // - packages/bun-types/bun.d.ts
         var labels = Label.initFill("");
-        labels.set(ImportKind.entry_point, "entry-point");
+        labels.set(ImportKind.entry_point_run, "entry-point-run");
+        labels.set(ImportKind.entry_point_build, "entry-point-build");
         labels.set(ImportKind.stmt, "import-statement");
         labels.set(ImportKind.require, "require-call");
         labels.set(ImportKind.dynamic, "dynamic-import");
@@ -45,7 +48,8 @@ pub const ImportKind = enum(u8) {
 
     pub const error_labels: Label = brk: {
         var labels = Label.initFill("");
-        labels.set(ImportKind.entry_point, "entry point");
+        labels.set(ImportKind.entry_point_run, "entry point (run)");
+        labels.set(ImportKind.entry_point_build, "entry point (build)");
         labels.set(ImportKind.stmt, "import");
         labels.set(ImportKind.require, "require()");
         labels.set(ImportKind.dynamic, "import()");
diff --git a/src/js_printer.zig b/src/js_printer.zig
index 8cb2b6327d..afd7fc1810 100644
--- a/src/js_printer.zig
+++ b/src/js_printer.zig
@@ -207,6 +207,7 @@ pub fn quoteForJSON(text: []const u8, output_: MutableString, comptime ascii_onl
 
 pub fn writePreQuotedString(text_in: []const u8, comptime Writer: type, writer: Writer, comptime quote_char: u8, comptime ascii_only: bool, comptime json: bool, comptime encoding: strings.Encoding) !void {
     const text = if (comptime encoding == .utf16) @as([]const u16, @alignCast(std.mem.bytesAsSlice(u16, text_in))) else text_in;
+    if (comptime json and quote_char != '"') @compileError("for json, quote_char must be '\"'");
     var i: usize = 0;
     const n: usize = text.len;
     while (i < n) {
diff --git a/src/options.zig b/src/options.zig
index add68926f8..9512e4bcc9 100644
--- a/src/options.zig
+++ b/src/options.zig
@@ -1344,7 +1344,7 @@ pub const ResolveFileExtensions = struct {
 
     pub fn kind(this: *const ResolveFileExtensions, kind_: bun.ImportKind, is_node_modules: bool) []const string {
         return switch (kind_) {
-            .stmt, .entry_point, .dynamic => this.group(is_node_modules).esm,
+            .stmt, .entry_point_build, .entry_point_run, .dynamic => this.group(is_node_modules).esm,
             else => this.group(is_node_modules).default,
         };
     }
diff --git a/src/resolver/package_json.zig b/src/resolver/package_json.zig
index c3435c06cb..21860d42a3 100644
--- a/src/resolver/package_json.zig
+++ b/src/resolver/package_json.zig
@@ -601,9 +601,9 @@ pub const PackageJSON = struct {
         input_path: string,
         dirname_fd: StoredFileDescriptorType,
         package_id: ?Install.PackageID,
-        comptime include_scripts_: @Type(.EnumLiteral),
-        comptime include_dependencies: @Type(.EnumLiteral),
-        comptime generate_hash_: @Type(.EnumLiteral),
+        comptime include_scripts_: enum { ignore_scripts, include_scripts },
+        comptime include_dependencies: enum { main, local, none },
+        comptime generate_hash_: enum { generate_hash, no_hash },
     ) ?PackageJSON {
         const generate_hash = generate_hash_ == .generate_hash;
         const include_scripts = include_scripts_ == .include_scripts;
@@ -687,155 +687,151 @@ pub const PackageJSON = struct {
             }
         }
 
-        // If we're coming from `bun run`
-        // We do not need to parse all this stuff.
-        if (comptime !include_scripts) {
-            if (json.asProperty("type")) |type_json| {
-                if (type_json.expr.asString(allocator)) |type_str| {
-                    switch (options.ModuleType.List.get(type_str) orelse options.ModuleType.unknown) {
-                        .cjs => {
-                            package_json.module_type = .cjs;
-                        },
-                        .esm => {
-                            package_json.module_type = .esm;
-                        },
-                        .unknown => {
-                            r.log.addRangeWarningFmt(
+        if (json.asProperty("type")) |type_json| {
+            if (type_json.expr.asString(allocator)) |type_str| {
+                switch (options.ModuleType.List.get(type_str) orelse options.ModuleType.unknown) {
+                    .cjs => {
+                        package_json.module_type = .cjs;
+                    },
+                    .esm => {
+                        package_json.module_type = .esm;
+                    },
+                    .unknown => {
+                        r.log.addRangeWarningFmt(
+                            &json_source,
+                            json_source.rangeOfString(type_json.loc),
+                            allocator,
+                            "\"{s}\" is not a valid value for \"type\" field (must be either \"commonjs\" or \"module\")",
+                            .{type_str},
+                        ) catch unreachable;
+                    },
+                }
+            } else {
+                r.log.addWarning(&json_source, type_json.loc, "The value for \"type\" must be a string") catch unreachable;
+            }
+        }
+
+        // Read the "main" fields
+        for (r.opts.main_fields) |main| {
+            if (json.asProperty(main)) |main_json| {
+                const expr: js_ast.Expr = main_json.expr;
+
+                if ((expr.asString(allocator))) |str| {
+                    if (str.len > 0) {
+                        package_json.main_fields.put(main, str) catch unreachable;
+                    }
+                }
+            }
+        }
+
+        // Read the "browser" property, but only when targeting the browser
+        if (r.opts.target == .browser) {
+            // We both want the ability to have the option of CJS vs. ESM and the
+            // option of having node vs. browser. The way to do this is to use the
+            // object literal form of the "browser" field like this:
+            //
+            //   "main": "dist/index.node.cjs.js",
+            //   "module": "dist/index.node.esm.js",
+            //   "browser": {
+            //     "./dist/index.node.cjs.js": "./dist/index.browser.cjs.js",
+            //     "./dist/index.node.esm.js": "./dist/index.browser.esm.js"
+            //   },
+            //
+            if (json.asProperty("browser")) |browser_prop| {
+                switch (browser_prop.expr.data) {
+                    .e_object => |obj| {
+                        // The value is an object
+
+                        // Remap all files in the browser field
+                        for (obj.properties.slice()) |*prop| {
+                            const _key_str = (prop.key orelse continue).asString(allocator) orelse continue;
+                            const value: js_ast.Expr = prop.value orelse continue;
+
+                            // Normalize the path so we can compare against it without getting
+                            // confused by "./". There is no distinction between package paths and
+                            // relative paths for these values because some tools (i.e. Browserify)
+                            // don't make such a distinction.
+                            //
+                            // This leads to weird things like a mapping for "./foo" matching an
+                            // import of "foo", but that's actually not a bug. Or arguably it's a
+                            // bug in Browserify but we have to replicate this bug because packages
+                            // do this in the wild.
+                            const key = allocator.dupe(u8, r.fs.normalize(_key_str)) catch unreachable;
+
+                            switch (value.data) {
+                                .e_string => |str| {
+                                    // If this is a string, it's a replacement package
+                                    package_json.browser_map.put(key, str.string(allocator) catch unreachable) catch unreachable;
+                                },
+                                .e_boolean => |boolean| {
+                                    if (!boolean.value) {
+                                        package_json.browser_map.put(key, "") catch unreachable;
+                                    }
+                                },
+                                else => {
+                                    r.log.addWarning(&json_source, value.loc, "Each \"browser\" mapping must be a string or boolean") catch unreachable;
+                                },
+                            }
+                        }
+                    },
+                    else => {},
+                }
+            }
+        }
+
+        if (json.asProperty("exports")) |exports_prop| {
+            if (ExportsMap.parse(bun.default_allocator, &json_source, r.log, exports_prop.expr, exports_prop.loc)) |exports_map| {
+                package_json.exports = exports_map;
+            }
+        }
+
+        if (json.asProperty("imports")) |imports_prop| {
+            if (ExportsMap.parse(bun.default_allocator, &json_source, r.log, imports_prop.expr, imports_prop.loc)) |imports_map| {
+                package_json.imports = imports_map;
+            }
+        }
+
+        if (json.get("sideEffects")) |side_effects_field| outer: {
+            if (side_effects_field.asBool()) |boolean| {
+                if (!boolean)
+                    package_json.side_effects = .{ .false = {} };
+            } else if (side_effects_field.asArray()) |array_| {
+                var array = array_;
+                // TODO: switch to only storing hashes
+                var map = SideEffects.Map{};
+                map.ensureTotalCapacity(allocator, array.array.items.len) catch unreachable;
+                while (array.next()) |item| {
+                    if (item.asString(allocator)) |name| {
+                        // TODO: support RegExp using JavaScriptCore <> C++ bindings
+                        if (strings.containsChar(name, '*')) {
+                            // https://sourcegraph.com/search?q=context:global+file:package.json+sideEffects%22:+%5B&patternType=standard&sm=1&groupBy=repo
+                            // a lot of these seem to be css files which we don't care about for now anyway
+                            // so we can just skip them in here
+                            if (strings.eqlComptime(std.fs.path.extension(name), ".css"))
+                                continue;
+
+                            r.log.addWarning(
                                 &json_source,
-                                json_source.rangeOfString(type_json.loc),
-                                allocator,
-                                "\"{s}\" is not a valid value for \"type\" field (must be either \"commonjs\" or \"module\")",
-                                .{type_str},
+                                item.loc,
+                                "wildcard sideEffects are not supported yet, which means this package will be deoptimized",
                             ) catch unreachable;
-                        },
-                    }
-                } else {
-                    r.log.addWarning(&json_source, type_json.loc, "The value for \"type\" must be a string") catch unreachable;
-                }
-            }
+                            map.deinit(allocator);
 
-            // Read the "main" fields
-            for (r.opts.main_fields) |main| {
-                if (json.asProperty(main)) |main_json| {
-                    const expr: js_ast.Expr = main_json.expr;
-
-                    if ((expr.asString(allocator))) |str| {
-                        if (str.len > 0) {
-                            package_json.main_fields.put(main, str) catch unreachable;
+                            package_json.side_effects = .{ .unspecified = {} };
+                            break :outer;
                         }
+
+                        var joined = [_]string{
+                            json_source.path.name.dirWithTrailingSlash(),
+                            name,
+                        };
+
+                        _ = map.getOrPutAssumeCapacity(
+                            bun.StringHashMapUnowned.Key.init(r.fs.join(&joined)),
+                        );
                     }
                 }
-            }
-
-            // Read the "browser" property, but only when targeting the browser
-            if (r.opts.target == .browser) {
-                // We both want the ability to have the option of CJS vs. ESM and the
-                // option of having node vs. browser. The way to do this is to use the
-                // object literal form of the "browser" field like this:
-                //
-                //   "main": "dist/index.node.cjs.js",
-                //   "module": "dist/index.node.esm.js",
-                //   "browser": {
-                //     "./dist/index.node.cjs.js": "./dist/index.browser.cjs.js",
-                //     "./dist/index.node.esm.js": "./dist/index.browser.esm.js"
-                //   },
-                //
-                if (json.asProperty("browser")) |browser_prop| {
-                    switch (browser_prop.expr.data) {
-                        .e_object => |obj| {
-                            // The value is an object
-
-                            // Remap all files in the browser field
-                            for (obj.properties.slice()) |*prop| {
-                                const _key_str = (prop.key orelse continue).asString(allocator) orelse continue;
-                                const value: js_ast.Expr = prop.value orelse continue;
-
-                                // Normalize the path so we can compare against it without getting
-                                // confused by "./". There is no distinction between package paths and
-                                // relative paths for these values because some tools (i.e. Browserify)
-                                // don't make such a distinction.
-                                //
-                                // This leads to weird things like a mapping for "./foo" matching an
-                                // import of "foo", but that's actually not a bug. Or arguably it's a
-                                // bug in Browserify but we have to replicate this bug because packages
-                                // do this in the wild.
-                                const key = allocator.dupe(u8, r.fs.normalize(_key_str)) catch unreachable;
-
-                                switch (value.data) {
-                                    .e_string => |str| {
-                                        // If this is a string, it's a replacement package
-                                        package_json.browser_map.put(key, str.string(allocator) catch unreachable) catch unreachable;
-                                    },
-                                    .e_boolean => |boolean| {
-                                        if (!boolean.value) {
-                                            package_json.browser_map.put(key, "") catch unreachable;
-                                        }
-                                    },
-                                    else => {
-                                        r.log.addWarning(&json_source, value.loc, "Each \"browser\" mapping must be a string or boolean") catch unreachable;
-                                    },
-                                }
-                            }
-                        },
-                        else => {},
-                    }
-                }
-            }
-
-            if (json.asProperty("exports")) |exports_prop| {
-                if (ExportsMap.parse(bun.default_allocator, &json_source, r.log, exports_prop.expr, exports_prop.loc)) |exports_map| {
-                    package_json.exports = exports_map;
-                }
-            }
-
-            if (json.asProperty("imports")) |imports_prop| {
-                if (ExportsMap.parse(bun.default_allocator, &json_source, r.log, imports_prop.expr, imports_prop.loc)) |imports_map| {
-                    package_json.imports = imports_map;
-                }
-            }
-
-            if (json.get("sideEffects")) |side_effects_field| outer: {
-                if (side_effects_field.asBool()) |boolean| {
-                    if (!boolean)
-                        package_json.side_effects = .{ .false = {} };
-                } else if (side_effects_field.asArray()) |array_| {
-                    var array = array_;
-                    // TODO: switch to only storing hashes
-                    var map = SideEffects.Map{};
-                    map.ensureTotalCapacity(allocator, array.array.items.len) catch unreachable;
-                    while (array.next()) |item| {
-                        if (item.asString(allocator)) |name| {
-                            // TODO: support RegExp using JavaScriptCore <> C++ bindings
-                            if (strings.containsChar(name, '*')) {
-                                // https://sourcegraph.com/search?q=context:global+file:package.json+sideEffects%22:+%5B&patternType=standard&sm=1&groupBy=repo
-                                // a lot of these seem to be css files which we don't care about for now anyway
-                                // so we can just skip them in here
-                                if (strings.eqlComptime(std.fs.path.extension(name), ".css"))
-                                    continue;
-
-                                r.log.addWarning(
-                                    &json_source,
-                                    item.loc,
-                                    "wildcard sideEffects are not supported yet, which means this package will be deoptimized",
-                                ) catch unreachable;
-                                map.deinit(allocator);
-
-                                package_json.side_effects = .{ .unspecified = {} };
-                                break :outer;
-                            }
-
-                            var joined = [_]string{
-                                json_source.path.name.dirWithTrailingSlash(),
-                                name,
-                            };
-
-                            _ = map.getOrPutAssumeCapacity(
-                                bun.StringHashMapUnowned.Key.init(r.fs.join(&joined)),
-                            );
-                        }
-                    }
-                    package_json.side_effects = .{ .map = map };
-                }
+                package_json.side_effects = .{ .map = map };
             }
         }
 
diff --git a/src/resolver/resolver.zig b/src/resolver/resolver.zig
index d427747c82..0e4250b271 100644
--- a/src/resolver/resolver.zig
+++ b/src/resolver/resolver.zig
@@ -687,7 +687,7 @@ pub const Resolver = struct {
         defer r.extension_order = original_order;
         r.extension_order = switch (kind) {
             .url, .at_conditional, .at => options.BundleOptions.Defaults.CSSExtensionOrder[0..],
-            .entry_point, .stmt, .dynamic => r.opts.extension_order.default.esm,
+            .entry_point_build, .entry_point_run, .stmt, .dynamic => r.opts.extension_order.default.esm,
             else => r.opts.extension_order.default.default,
         };
 
@@ -731,7 +731,7 @@ pub const Resolver = struct {
 
         // Certain types of URLs default to being external for convenience,
         // while these rules should not be applied to the entrypoint as it is never external (#12734)
-        if (kind != .entry_point and
+        if (kind != .entry_point_build and kind != .entry_point_run and
             (r.isExternalPattern(import_path) or
             // "fill: url(#filter);"
             (kind.isFromCSS() and strings.startsWith(import_path, "#")) or
@@ -926,7 +926,7 @@ pub const Resolver = struct {
                             .primary_side_effects_data = .no_side_effects__pure_data,
                         };
                     },
-                    .import => |path| return r.resolve(r.fs.top_level_dir, path, .entry_point),
+                    .import => |path| return r.resolve(r.fs.top_level_dir, path, .entry_point_build),
                 }
                 return .{};
             }
@@ -1155,7 +1155,7 @@ pub const Resolver = struct {
 
         // Check both relative and package paths for CSS URL tokens, with relative
         // paths taking precedence over package paths to match Webpack behavior.
-        const is_package_path = isPackagePathNotAbsolute(import_path);
+        const is_package_path = kind != .entry_point_run and isPackagePathNotAbsolute(import_path);
         var check_relative = !is_package_path or kind == .url;
         var check_package = is_package_path;
 
diff --git a/src/shell/interpreter.zig b/src/shell/interpreter.zig
index dd99771700..8ed314fe94 100644
--- a/src/shell/interpreter.zig
+++ b/src/shell/interpreter.zig
@@ -1473,7 +1473,7 @@ pub const Interpreter = struct {
         return code;
     }
 
-    pub fn initAndRunFromSource(ctx: bun.CLI.Command.Context, mini: *JSC.MiniEventLoop, path_for_errors: []const u8, src: []const u8) !ExitCode {
+    pub fn initAndRunFromSource(ctx: bun.CLI.Command.Context, mini: *JSC.MiniEventLoop, path_for_errors: []const u8, src: []const u8, cwd: ?[]const u8) !ExitCode {
         bun.Analytics.Features.standalone_shell += 1;
         var shargs = ShellArgs.init();
         defer shargs.deinit();
@@ -1505,7 +1505,7 @@ pub const Interpreter = struct {
             shargs,
             jsobjs,
             null,
-            null,
+            cwd,
         )) {
             .err => |*e| {
                 e.throwMini();
diff --git a/src/transpiler.zig b/src/transpiler.zig
index cb5eb891e5..6be3b668fe 100644
--- a/src/transpiler.zig
+++ b/src/transpiler.zig
@@ -397,7 +397,7 @@ pub const Transpiler = struct {
     }
 
     fn _resolveEntryPoint(transpiler: *Transpiler, entry_point: string) !_resolver.Result {
-        return transpiler.resolver.resolveWithFramework(transpiler.fs.top_level_dir, entry_point, .entry_point) catch |err| {
+        return transpiler.resolver.resolveWithFramework(transpiler.fs.top_level_dir, entry_point, .entry_point_build) catch |err| {
             // Relative entry points that were not resolved to a node_modules package are
             // interpreted as relative to the current working directory.
             if (!std.fs.path.isAbsolute(entry_point) and
@@ -407,7 +407,7 @@ pub const Transpiler = struct {
                     return transpiler.resolver.resolve(
                         transpiler.fs.top_level_dir,
                         try strings.append(transpiler.allocator, "./", entry_point),
-                        .entry_point,
+                        .entry_point_build,
                     ) catch {
                         // return the original error
                         break :brk;
@@ -1784,7 +1784,7 @@ pub const Transpiler = struct {
                 js_ast.Stmt.Data.Store.reset();
             }
 
-            const result = transpiler.resolver.resolve(transpiler.fs.top_level_dir, entry, .entry_point) catch |err| {
+            const result = transpiler.resolver.resolve(transpiler.fs.top_level_dir, entry, .entry_point_build) catch |err| {
                 Output.prettyError("Error resolving \"{s}\": {s}\n", .{ entry, @errorName(err) });
                 continue;
             };
diff --git a/test/cli/install/bun-run.test.ts b/test/cli/install/bun-run.test.ts
index 3b363ba90f..4697357e22 100644
--- a/test/cli/install/bun-run.test.ts
+++ b/test/cli/install/bun-run.test.ts
@@ -1,4 +1,4 @@
-import { file, spawn, spawnSync } from "bun";
+import { $, file, spawn, spawnSync } from "bun";
 import { beforeEach, describe, expect, it } from "bun:test";
 import { exists, mkdir, rm, writeFile } from "fs/promises";
 import {
@@ -12,6 +12,7 @@ import {
   readdirSorted,
 } from "harness";
 import { join } from "path";
+import { chmodSync } from "fs";
 
 let run_dir: string;
 
@@ -649,3 +650,338 @@ describe("should handle run case", () => {
     });
   }
 });
+
+describe("'bun run' priority", async () => {
+  // priority:
+  // - 1: run script with matching name
+  // - 2: load module and run that module
+  // - 3: execute a node_modules/.bin/<X> command
+  // - 4: ('run' only): execute a system command, like 'ls'
+  const dir = tempDirWithFiles("test", {
+    "test": { "index.js": "console.log('test/index.js');" },
+    "build": { "script.js": "console.log('build/script.js');" },
+    "consume": { "index.js": "console.log('consume/index.js');" },
+    "index.js": "console.log('index.js')",
+    "main.js": "console.log('main.js')",
+    "typescript.ts": "console.log('typescript.ts')",
+    "sample.js": "console.log('sample.js')",
+    "noext": "console.log('noext')",
+    "folderandfile": { "index.js": "console.log('folderandfile/index.js')" },
+    "folderandfile.js": "console.log('folderandfile.js')",
+    "shellscript.sh": "echo shellscript.sh",
+    ".secretscript.js": "console.log('.secretscript.js')",
+    "package.json": JSON.stringify({
+      scripts: {
+        "build": "echo scripts/build",
+        "test": "echo scripts/test",
+        "sample.js": "echo scripts/sample.js",
+        "§'.js": 'echo "scripts/§\'.js"',
+        "test.todo": "echo scripts/test.todo",
+        "/absolute": "echo DO_NOT_RUN",
+        "./relative": "echo DO_NOT_RUN",
+      },
+      main: "main.js",
+    }),
+    "§'.js": 'console.log("§\'.js")',
+    "node_modules": { ".bin": { "confabulate": `#!${bunExe()}\nconsole.log("node_modules/.bin/confabulate")` } },
+  });
+  chmodSync(dir + "/node_modules/.bin/confabulate", 0o755);
+
+  const commands: {
+    command: string[];
+    req_run?: boolean;
+    stdout: string;
+    stderr?: string | RegExp;
+    exitCode?: number;
+  }[] = [
+    { command: ["test"], stdout: "scripts/test", stderr: "$ echo scripts/test", req_run: true },
+    { command: ["build"], stdout: "scripts/build", stderr: "$ echo scripts/build", req_run: true },
+    { command: ["consume"], stdout: "consume/index.js", stderr: "" },
+
+    { command: ["test/index"], stdout: "test/index.js", stderr: "" },
+    { command: ["test/index.js"], stdout: "test/index.js", stderr: "" },
+    { command: ["build/script"], stdout: "build/script.js", stderr: "" },
+    { command: ["build/script.js"], stdout: "build/script.js", stderr: "" },
+    { command: ["consume/index"], stdout: "consume/index.js", stderr: "" },
+    { command: ["consume/index.js"], stdout: "consume/index.js", stderr: "" },
+
+    { command: ["./test"], stdout: "test/index.js", stderr: "" },
+    { command: ["./build"], stdout: "", stderr: /error: Module not found "\.(\/|\\|\\\\)build"|EACCES/, exitCode: 1 },
+    { command: ["./consume"], stdout: "consume/index.js", stderr: "" },
+
+    { command: ["index.js"], stdout: "index.js", stderr: "" },
+    { command: ["./index.js"], stdout: "index.js", stderr: "" },
+    { command: ["index"], stdout: "index.js", stderr: "" },
+    { command: ["./index"], stdout: "index.js", stderr: "" },
+
+    { command: ["."], stdout: "main.js", stderr: "" },
+    { command: ["./"], stdout: "main.js", stderr: "" },
+
+    { command: ["typescript.ts"], stdout: "typescript.ts", stderr: "" },
+    { command: ["./typescript.ts"], stdout: "typescript.ts", stderr: "" },
+    { command: ["typescript.js"], stdout: "typescript.ts", stderr: "" },
+    { command: ["./typescript.js"], stdout: "typescript.ts", stderr: "" },
+    { command: ["typescript"], stdout: "typescript.ts", stderr: "" },
+    { command: ["./typescript"], stdout: "typescript.ts", stderr: "" },
+
+    { command: ["sample.js"], stdout: "scripts/sample.js", stderr: "$ echo scripts/sample.js", req_run: true },
+    { command: ["sample.js"], stdout: "sample.js", stderr: "", req_run: false },
+    { command: ["./sample.js"], stdout: "sample.js", stderr: "" },
+    { command: ["sample"], stdout: "sample.js", stderr: "" },
+    { command: ["./sample"], stdout: "sample.js", stderr: "" },
+
+    { command: ["test.todo"], stdout: "scripts/test.todo", stderr: "$ echo scripts/test.todo" },
+
+    { command: ["§'.js"], stdout: "scripts/§'.js", stderr: '$ echo "scripts/§\'.js"', req_run: true },
+    { command: ["§'.js"], stdout: "§'.js", stderr: "", req_run: false },
+    { command: ["./§'.js"], stdout: "§'.js", stderr: "" },
+    { command: ["§'"], stdout: "§'.js", stderr: "" },
+    { command: ["./§'"], stdout: "§'.js", stderr: "" },
+
+    { command: ["noext"], stdout: "noext", stderr: "" },
+    { command: ["./noext"], stdout: "noext", stderr: "" },
+
+    { command: ["folderandfile"], stdout: "folderandfile.js", stderr: "" },
+    { command: ["./folderandfile"], stdout: "folderandfile.js", stderr: "" },
+    { command: ["folderandfile.js"], stdout: "folderandfile.js", stderr: "" },
+    { command: ["./folderandfile.js"], stdout: "folderandfile.js", stderr: "" },
+    ...(isWindows
+      ? [] // on windows these ones run "folderandfile.js" but the absolute path ones run "folderandfile/index.js"
+      : [
+          { command: ["folderandfile/"], stdout: "folderandfile/index.js", stderr: "" },
+          { command: ["./folderandfile/"], stdout: "folderandfile/index.js", stderr: "" },
+        ]),
+    { command: ["folderandfile/index"], stdout: "folderandfile/index.js", stderr: "" },
+    { command: ["./folderandfile/index"], stdout: "folderandfile/index.js", stderr: "" },
+    { command: ["folderandfile/index.js"], stdout: "folderandfile/index.js", stderr: "" },
+    { command: ["./folderandfile/index.js"], stdout: "folderandfile/index.js", stderr: "" },
+    { command: [dir + "/folderandfile"], stdout: "folderandfile.js", stderr: "" },
+    { command: [dir + "/folderandfile/"], stdout: "folderandfile/index.js", stderr: "" },
+
+    { command: ["shellscript.sh"], stdout: "shellscript.sh", stderr: "" },
+    { command: ["./shellscript.sh"], stdout: "shellscript.sh", stderr: "" },
+
+    { command: [".secretscript.js"], stdout: ".secretscript.js", stderr: "" },
+    { command: ["./.secretscript"], stdout: ".secretscript.js", stderr: "" },
+    { command: [dir + "/.secretscript"], stdout: ".secretscript.js", stderr: "" },
+
+    {
+      command: ["/absolute"],
+      stdout: "",
+      stderr: /error: Module not found "(\/|\\|\\\\)absolute"|EACCES/,
+      exitCode: 1,
+    },
+    {
+      command: ["./relative"],
+      stdout: "",
+      stderr: /error: Module not found ".(\/|\\|\\\\)relative"|EACCES/,
+      exitCode: 1,
+    },
+
+    ...(isWindows
+      ? [
+          // TODO: node_modules command
+          // TODO: system command
+        ]
+      : [
+          // node_modules command
+          { command: ["confabulate"], stdout: "node_modules/.bin/confabulate", stderr: "" },
+
+          // system command
+          { command: ["echo", "abc"], stdout: "abc", stderr: "", req_run: true },
+          { command: ["echo", "abc"], stdout: "", exitCode: 1, req_run: false },
+        ]),
+
+    // TODO: test preloads (https://bun.sh/docs/runtime/bunfig#preload), test $npm_lifecycle_event
+    // TODO: test with path overrides in tsconfig.json
+  ];
+  if (isWindows) {
+    for (const cmd of [...commands]) {
+      if (cmd.command[0].includes("/")) {
+        commands.push({
+          ...cmd,
+          command: [cmd.command[0].replaceAll("/", "\\"), ...cmd.command.slice(1)],
+        });
+      }
+    }
+  }
+
+  for (const cmd of commands) {
+    for (const flag of [[], ["--bun"]]) {
+      for (const postflag of cmd.req_run === true ? [["run"]] : cmd.req_run === false ? [[]] : [[], ["run"]]) {
+        const full_command = [...flag, ...postflag, ...cmd.command];
+        it("bun " + full_command.join(" "), () => {
+          const { stdout, stderr, exitCode } = spawnSync({
+            cmd: [bunExe(), ...full_command],
+            cwd: dir,
+            env: { ...bunEnv, BUN_DEBUG_QUIET_LOGS: "1" },
+          });
+
+          if (cmd.stderr != null && typeof cmd.stderr !== "string") expect(stderr.toString()).toMatch(cmd.stderr);
+          expect({
+            ...(cmd.stderr != null && typeof cmd.stderr === "string" ? { stderr: stderr.toString().trim() } : {}),
+            stdout: stdout.toString().trim(),
+            exitCode,
+          }).toStrictEqual({
+            ...(cmd.stderr != null && typeof cmd.stderr === "string" ? { stderr: cmd.stderr } : {}),
+            stdout: cmd.stdout,
+            exitCode: cmd.exitCode ?? 0,
+          });
+        });
+      }
+    }
+  }
+});
+
+it("should run from stdin", async () => {
+  const res = await $`echo "console.log('hello')" | bun run -`.text();
+  expect(res).toBe(`hello\n`);
+});
+
+describe.todo("run from stdin", async () => {
+  // TODO: write this test
+  // note limit of around 1gb when running from stdin
+  // - which says 'catch return false'
+});
+
+describe("should run scripts from the project root (#16169)", async () => {
+  const dir = tempDirWithFiles("test", {
+    "run_here": {
+      "myscript.ts": "console.log('successful run')",
+      "package.json": JSON.stringify({
+        scripts: { "sample": "pwd", "runscript": "bun myscript.ts" },
+      }),
+      "dont_run_in_here": {
+        "runme.ts": "console.log('do run this script')",
+      },
+    },
+  });
+
+  it("outside", () => {
+    const run_outside = spawnSync({
+      cmd: [bunExe(), "run", "sample"],
+      cwd: dir + "/run_here",
+      env: bunEnv,
+    });
+    expect(run_outside.stdout.toString()).toContain("run_here");
+    expect(run_outside.stdout.toString()).not.toContain("dont_run_in_here");
+    expect(run_outside.exitCode).toBe(0);
+  });
+
+  it("inside", () => {
+    const run_inside = spawnSync({
+      cmd: [bunExe(), "run", "sample"],
+      cwd: dir + "/run_here/dont_run_in_here",
+      env: bunEnv,
+    });
+    expect(run_inside.stdout.toString()).toContain("run_here");
+    expect(run_inside.stdout.toString()).not.toContain("dont_run_in_here");
+    expect(run_inside.exitCode).toBe(0);
+  });
+
+  it("inside --shell=bun", () => {
+    const run_inside = spawnSync({
+      cmd: [bunExe(), "--shell=bun", "run", "sample"],
+      cwd: dir + "/run_here/dont_run_in_here",
+      env: bunEnv,
+    });
+    expect(run_inside.stdout.toString()).toContain("run_here");
+    expect(run_inside.stdout.toString()).not.toContain("dont_run_in_here");
+    expect(run_inside.exitCode).toBe(0);
+  });
+
+  it("inside script", () => {
+    const run_inside = spawnSync({
+      cmd: [bunExe(), "run", "runme.ts"],
+      cwd: dir + "/run_here/dont_run_in_here",
+      env: bunEnv,
+    });
+    expect(run_inside.stdout.toString()).toContain("do run this script");
+    expect(run_inside.exitCode).toBe(0);
+  });
+
+  it("inside wrong script", () => {
+    const run_inside = spawnSync({
+      cmd: [bunExe(), "run", "myscript.ts"],
+      cwd: dir + "/run_here/dont_run_in_here",
+      env: bunEnv,
+    });
+    const stderr = run_inside.stderr.toString();
+    if (stderr.includes("myscript.ts") && stderr.includes("EACCES")) {
+      // for some reason on musl, the run_here folder is in $PATH
+      // 'error: Failed to run "myscript.ts" due to:\nEACCES: run_here/myscript.ts: Permission denied (posix_spawn())'
+    } else {
+      expect(stderr).toBe('error: Module not found "myscript.ts"\n');
+    }
+    expect(run_inside.exitCode).toBe(1);
+  });
+
+  it("outside 2", () => {
+    const run_outside_script = spawnSync({
+      cmd: [bunExe(), "runscript"],
+      cwd: dir + "/run_here",
+      env: bunEnv,
+    });
+    expect(run_outside_script.stdout.toString()).toBe("successful run\n");
+    expect(run_outside_script.exitCode).toBe(0);
+  });
+
+  it("inside 2", () => {
+    const run_inside_script = spawnSync({
+      cmd: [bunExe(), "runscript"],
+      cwd: dir + "/run_here/dont_run_in_here",
+      env: bunEnv,
+    });
+    expect(run_inside_script.stdout.toString()).toBe("successful run\n");
+    expect(run_inside_script.exitCode).toBe(0);
+  });
+});
+
+describe("run main within monorepo", async () => {
+  const dir = tempDirWithFiles("test", {
+    "package.json": JSON.stringify({
+      name: "monorepo_root",
+      main: "monorepo_root.ts",
+      workspaces: ["packages/*"],
+    }),
+    "monorepo_root.ts": "console.log('monorepo_root')",
+    "packages": {
+      "package_a": {
+        "package.json": JSON.stringify({ name: "package_a", main: "package_a.ts" }),
+        "package_a.ts": "console.log('package_a')",
+      },
+      "package_b": {
+        "package.json": JSON.stringify({ name: "package_b" }),
+      },
+    },
+  });
+
+  it("should run main from monorepo root", () => {
+    const { stdout, stderr, exitCode } = spawnSync({
+      cmd: [bunExe(), "."],
+      cwd: dir,
+      env: bunEnv,
+    });
+    expect(stdout.toString()).toBe("monorepo_root\n");
+    expect(exitCode).toBe(0);
+  });
+
+  it("should run package_a from package_a", () => {
+    const { stdout, stderr, exitCode } = spawnSync({
+      cmd: [bunExe(), "."],
+      cwd: dir + "/packages/package_a",
+      env: bunEnv,
+    });
+    expect(stdout.toString()).toBe("package_a\n");
+    expect(exitCode).toBe(0);
+  });
+
+  it("should fail from package_b", () => {
+    const { stdout, stderr, exitCode } = spawnSync({
+      cmd: [bunExe(), "."],
+      cwd: dir + "/packages/package_b",
+      env: bunEnv,
+    });
+    expect(exitCode).toBe(1);
+  });
+});
diff --git a/test/cli/run/if-present.test.ts b/test/cli/run/if-present.test.ts
index 824ee4a239..96e712a466 100644
--- a/test/cli/run/if-present.test.ts
+++ b/test/cli/run/if-present.test.ts
@@ -50,7 +50,7 @@ describe("bun", () => {
       stderr: "pipe",
     });
     expect(stdout.toString()).toBeEmpty();
-    expect(stderr.toString()).toMatch(/File not found/);
+    expect(stderr.toString()).toMatch(/Module not found/);
     expect(exitCode).toBe(1);
   });
 });
diff --git a/test/js/bun/wasm/wasi.test.js b/test/js/bun/wasm/wasi.test.js
index 9b02de881b..5e6994a504 100644
--- a/test/js/bun/wasm/wasi.test.js
+++ b/test/js/bun/wasm/wasi.test.js
@@ -3,12 +3,20 @@ import { expect, it } from "bun:test";
 import { bunEnv, bunExe } from "harness";
 
 it("Should support printing 'hello world'", () => {
-  const { stdout, exitCode } = spawnSync({
+  const { stdout, stderr, exitCode } = spawnSync({
     cmd: [bunExe(), import.meta.dir + "/hello-wasi.wasm"],
     stdout: "pipe",
+    stderr: "pipe",
     env: bunEnv,
   });
 
-  expect(stdout.toString()).toEqual("hello world\n");
-  expect(exitCode).toBe(0);
+  expect({
+    stdout: stdout.toString(),
+    stderr: stderr.toString(),
+    exitCode: exitCode,
+  }).toEqual({
+    stdout: "hello world\n",
+    stderr: "",
+    exitCode: 0,
+  });
 });
diff --git a/test/regression/issue/10132.test.ts b/test/regression/issue/10132.test.ts
index 77a3018a1d..f4bf2790a1 100644
--- a/test/regression/issue/10132.test.ts
+++ b/test/regression/issue/10132.test.ts
@@ -50,14 +50,14 @@ echo My name is bun-hello2
   }
 });
 
-test("issue #10132, bun run sets cwd", async () => {
+test("bun run sets cwd for script, matching npm", async () => {
   $.cwd(dir);
   const currentPwd = (await $`${bunExe()} run get-pwd`.text()).trim();
   expect(currentPwd).toBe(dir);
 
   const currentPwd2 = join(currentPwd, "subdir", "one");
   $.cwd(currentPwd2);
-  expect((await $`${bunExe()} run get-pwd`.text()).trim()).toBe(currentPwd2);
+  expect((await $`${bunExe()} run get-pwd`.text()).trim()).toBe(dir);
 
   $.cwd(process.cwd());
 });