Make the entry point of the node shim the main module

src/jsc/VirtualMachine.rs

@@ -150,6 +150,9 @@ pub struct VirtualMachine {
     /// `RawSlice` carries the BACKREF outlives-holder invariant — read via
     /// `main()`.
     main: bun_ptr::RawSlice<u8>,
+    /// `process.argv[1]` when it is not `main`: the `node` shim keeps the path
+    /// the user gave, like Node.
+    main_for_argv: Option<&'static [u8]>,
     pub main_is_html_entrypoint: bool,
     pub main_resolved_path: bun_core::String,
     pub main_hash: u32,
@@ -3120,6 +3123,7 @@ impl VirtualMachine {
             // `log` is a fresh leaked Box; outlives the VM.
             addr_of_mut!((*vm).log).write(NonNull::new(log));
             addr_of_mut!((*vm).main).write(bun_ptr::RawSlice::EMPTY);
+            addr_of_mut!((*vm).main_for_argv).write(None);
             addr_of_mut!((*vm).main_hash).write(0);
             addr_of_mut!((*vm).main_resolved_path).write(bun_core::String::EMPTY);
             addr_of_mut!((*vm).hide_bun_stackframes).write(true);
@@ -3308,6 +3312,18 @@ impl VirtualMachine {
         self.main = bun_ptr::RawSlice::new(path);
     }
 
+    /// The entry path for `process.argv[1]`: `main()`, unless
+    /// `set_main_for_argv` gave another path.
+    #[inline]
+    pub fn main_for_argv(&self) -> &[u8] {
+        self.main_for_argv.unwrap_or_else(|| self.main())
+    }
+
+    #[inline]
+    pub fn set_main_for_argv(&mut self, path: &'static [u8]) {
+        self.main_for_argv = Some(path);
+    }
+
     /// `eventLoop().waitForPromise(promise)` — spin tick/auto_tick until
     /// `promise` settles. Thin forwarder; body lives in
     /// [`crate::event_loop::EventLoop::wait_for_promise`].

src/runtime/cli/fuzzilli_command.rs

@@ -8,7 +8,7 @@ use bun_core::{Environment, Global};
 use bun_sys::{self as sys, Fd, FdExt, O};
 
 #[cfg(unix)]
-use super::run_command::RunCommand;
+use super::run_command::{EntryPath, RunCommand};
 use crate::Command;
 
 pub(crate) struct FuzzilliCommand;
@@ -92,7 +92,12 @@ impl FuzzilliCommand {
             let temp_path: &[u8] = b"/tmp/bun-fuzzilli-reprl.js";
             // The `Run.boot` entry point is hosted on `RunCommand` to avoid the
             // higher-tier crate cycle (see run_command.rs §`Run`).
-            let result = RunCommand::boot(_ctx, temp_path.to_vec().into_boxed_slice(), None);
+            let result = RunCommand::boot(
+                _ctx,
+                temp_path.to_vec().into_boxed_slice(),
+                EntryPath::Resolved,
+                None,
+            );
 
             // `defer fd.close()` — Fd is Copy and has no Drop; close explicitly.
             temp_file_fd.close();

src/runtime/cli/run_command.rs

@@ -94,6 +94,18 @@ pub(crate) struct ConfigureEnvOptions {
     pub(crate) store_root_fd: bool,
 }
 
+/// What the `entry_path` of [`RunCommand::boot`] names.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum EntryPath {
+    /// The file to run.
+    Resolved,
+    /// A path as `node` takes it: a directory, or a file without its
+    /// extension, also runs. `Run::start` resolves it to the file to run and
+    /// keeps the given path as `process.argv[1]`, like Node's `resolveMainPath`:
+    /// https://github.com/nodejs/node/blob/v26.3.0/lib/internal/modules/run_main.js#L29-L45
+    Unresolved,
+}
+
 pub(crate) struct RunCommand;
 
 impl RunCommand {
@@ -934,6 +946,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
     pub(crate) fn boot(
         ctx: &mut ContextData,
         entry_path: Box<[u8]>,
+        entry_kind: EntryPath,
         loader: Option<Loader>,
     ) -> crate::Result<()> {
         if !ctx.debug.loaded_bunfig {
@@ -1111,10 +1124,30 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             ctx,
             vm,
             entry_path: run_entry,
+            entry_kind,
         }
         .start()
     }
 
+    /// Resolve `entry` to the file to run, like `bun <entry>` does. On `None`
+    /// the module loader reports the failure when it imports `entry`.
+    fn resolve_entry_path(vm: &mut VirtualMachine, entry: &'static [u8]) -> Option<&'static [u8]> {
+        let top_level_dir = vm.top_level_dir();
+        // Like the module loader, keep the resolver's messages out of `vm.log`.
+        let mut log = bun_ast::Log::default();
+        let resolver = &raw mut vm.transpiler.resolver;
+        // SAFETY: `resolver` is a field of the live VM. `log` is declared
+        // before the guard, so the guard restores the log before `log` drops.
+        let _restore_log = unsafe {
+            bun_resolver::Resolver::scoped_log(resolver, ::core::ptr::NonNull::from(&mut log))
+        };
+        // SAFETY: `vm` is borrowed for this call, so nothing else uses its resolver.
+        let resolved = unsafe { &mut *resolver }
+            .resolve(top_level_dir, entry, bun_ast::ImportKind::EntryPointRun)
+            .ok()?;
+        Some(resolved.path_const()?.text)
+    }
+
     /// Entry point for
     /// `bun build --compile` executables. Mirrors [`boot`] but routes through
     /// `VirtualMachine::init_with_module_graph` and applies the standalone
@@ -1230,6 +1263,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             ctx,
             vm,
             entry_path: entry,
+            entry_kind: EntryPath::Resolved,
         }
         .start()
     }
@@ -1250,6 +1284,7 @@ pub struct Run<'a> {
     /// reloader stores them too (`boot` leaks the `Box<[u8]>`, cron mode uses
     /// the runner arena).
     entry_path: &'static [u8],
+    entry_kind: EntryPath,
 }
 
 // `on_unhandled_rejection_before_close` is a plain fn pointer stored on the
@@ -1299,6 +1334,7 @@ impl Run<'_> {
             ctx,
             vm,
             entry_path: mut entry,
+            entry_kind,
         } = self;
         let _api_lock = vm.global().vm().get_api_lock();
 
@@ -1431,6 +1467,18 @@ impl Run<'_> {
             }
         }
 
+        // `vm.main()` must be the key the module loader gives the entry module.
+        // Resolve only now: the resolver has its final options and, under
+        // `--watch` and `--hot`, its watcher, as it has for every import.
+        if entry_kind == EntryPath::Unresolved
+            && vm.module_loader.eval_source.is_none()
+            && let Some(resolved) = RunCommand::resolve_entry_path(vm, entry)
+            && resolved != entry
+        {
+            vm.set_main_for_argv(entry);
+            entry = resolved;
+        }
+
         match vm.load_entry_point(entry) {
             Ok(promise) => {
                 // SAFETY: `promise` is a live GC cell returned by the module loader.
@@ -1710,7 +1758,7 @@ impl RunCommand {
         // owned copy by value.
         let owned: Box<[u8]> = path.to_vec().into_boxed_slice();
 
-        if let Err(err) = Self::boot(ctx, owned, loader) {
+        if let Err(err) = Self::boot(ctx, owned, EntryPath::Resolved, loader) {
             Self::boot_failed_exit(ctx, paths::basename(path), &err);
         }
         true
@@ -2869,7 +2917,7 @@ impl RunCommand {
         // `basename(target_name)` (= "-"), not `basename(entry_path)`
         // (= "[stdin]"), in the error message.
         let owned: Box<[u8]> = entry_path.to_vec().into_boxed_slice();
-        if let Err(err) = Self::boot(ctx, owned, None) {
+        if let Err(err) = Self::boot(ctx, owned, EntryPath::Resolved, None) {
             Self::boot_failed_exit(ctx, b"-", &err);
         }
         Ok(true)
@@ -2919,7 +2967,7 @@ impl RunCommand {
         let entry: Box<[u8]> = entry_point_buf[..cwd_len + EVAL_TRIGGER.len()]
             .to_vec()
             .into_boxed_slice();
-        Self::boot(ctx, entry, None)
+        Self::boot(ctx, entry, EntryPath::Resolved, None)
     }
 
     /// `node` argv0 emulation. Port of `execAsIfNode`.
@@ -2954,7 +3002,7 @@ impl RunCommand {
             let entry: Box<[u8]> = entry_point_buf[..cwd_len + EVAL_TRIGGER.len()]
                 .to_vec()
                 .into_boxed_slice();
-            return Self::boot(ctx, entry, None);
+            return Self::boot(ctx, entry, EntryPath::Resolved, None);
         }
 
         if ctx.positionals.is_empty() {
@@ -2997,7 +3045,7 @@ impl RunCommand {
         // `Global::configure_allocator` and (b) uses the
         // `Output.err(err, "Failed to run script \"...\"")` form.
         let basename: Box<[u8]> = paths::basename(&normalized).to_vec().into_boxed_slice();
-        if let Err(err) = Self::boot(ctx, normalized, None) {
+        if let Err(err) = Self::boot(ctx, normalized, EntryPath::Unresolved, None) {
             Self::exec_as_if_node_boot_failed(ctx, &basename, err);
         }
         Ok(())
@@ -4036,7 +4084,12 @@ impl BunXFastPath {
             ::core::slice::from_raw_parts_mut(raw.cast::<u8>(), bun_paths::PATH_MAX_WIDE * 2)
         };
         let utf8 = strings::convert_utf16_to_utf8_in_buffer(out_buf, wpath);
-        if let Err(err) = RunCommand::boot(ctx, utf8.to_vec().into_boxed_slice(), None) {
+        if let Err(err) = RunCommand::boot(
+            ctx,
+            utf8.to_vec().into_boxed_slice(),
+            EntryPath::Resolved,
+            None,
+        ) {
             // SAFETY: `ctx.log` was set in `create_context_data`.
             let _ = unsafe { &mut *ctx.log }.print(std::ptr::from_mut(Output::error_writer()));
             Output::err(

src/runtime/node/node_process.rs

@@ -385,7 +385,7 @@ mod _impl {
             if worker.is_some_and(|w| w.eval_mode()) {
                 args_list.push(BunString::static_("[worker eval]"));
             } else {
-                args_list.push(BunString::borrow_utf8(vm.main()));
+                args_list.push(BunString::borrow_utf8(vm.main_for_argv()));
             }
         }
 

src/runtime/shell/interpreter.rs

@@ -1701,7 +1701,7 @@ impl Interpreter {
                 // SAFETY: `bun_vm()` on a JS event loop returns the live
                 // `*VirtualMachine` owning that loop.
                 let vm = unsafe { &*vm_ptr };
-                let main = vm.main();
+                let main = vm.main_for_argv();
                 if !main.is_empty() {
                     if int == 0 {
                         out.extend_from_slice(main);