Decide in _resolve whether a ? is part of a path or starts a query

src/bundler/options.rs

@@ -443,8 +443,18 @@
     let specifier = slice;
     let mut query: &[u8] = b"";
 
     if let Some(i) = strings::index_of_char(slice, b'?') {
-        let i = i as usize;
+        let mut i = i as usize;
+        // A '?' that sits before a path separator is part of a directory name
+        // (POSIX allows '?' in filenames), not a query string. Only split on a
+        // '?' that appears in the final path segment. #7928
+        if strings::contains_char(&slice[i + 1..], b'/') {
+            let base = strings::last_index_of_char(slice, b'/').unwrap_or(0) + 1;
+            match strings::index_of_char(&slice[base..], b'?') {
+                Some(j) => i = base + j as usize,
+                None => return (slice, specifier, query),
+            }
+        }
         query = &slice[i..];
         slice = &slice[..i];
     }

src/jsc/VirtualMachine.rs

@@ -2938,7 +2938,17 @@ fn normalize_specifier_for_resolution<'a>(
     specifier_: &'a [u8],
     query_string: &mut &'a [u8],
 ) -> &'a [u8] {
-    if let Some(i) = bun_core::strings::index_of_char_usize(specifier_, b'?') {
+    if let Some(mut i) = bun_core::strings::index_of_char_usize(specifier_, b'?') {
+        // A '?' that sits before a path separator is part of a directory name
+        // (POSIX allows '?' in filenames), not a query string. Only split on a
+        // '?' that appears in the final path segment. #7928
+        if bun_core::strings::contains_char(&specifier_[i + 1..], b'/') {
+            let base = bun_core::strings::last_index_of_char(specifier_, b'/').unwrap_or(0) + 1;
+            match bun_core::strings::index_of_char_usize(&specifier_[base..], b'?') {
+                Some(j) => i = base + j,
+                None => return specifier_,
+            }
+        }
         *query_string = &specifier_[i..];
         &specifier_[..i]
     } else {

src/runtime/jsc_hooks.rs

@@ -3916,8 +3916,17 @@
     }
     let specifier = slice;
     let mut query: &[u8] = b"";
-    if let Some(i) = bun_core::strings::index_of_char_usize(slice, b'?') {
-        let i = i as usize;
+    if let Some(mut i) = bun_core::strings::index_of_char_usize(slice, b'?') {
+        // A '?' that sits before a path separator is part of a directory name
+        // (POSIX allows '?' in filenames), not a query string. Only split on a
+        // '?' that appears in the final path segment. #7928
+        if bun_core::strings::contains_char(&slice[i + 1..], b'/') {
+            let base = bun_core::strings::last_index_of_char(slice, b'/').unwrap_or(0) + 1;
+            match bun_core::strings::index_of_char_usize(&slice[base..], b'?') {
+                Some(j) => i = base + j,
+                None => return (slice, specifier, query),
+            }
+        }
         query = &slice[i..];
         slice = &slice[..i];
     }
@@ -4843,8 +4852,17 @@
     specifier: &'a [u8],
     query_string: &mut &'a [u8],
 ) -> &'a [u8] {
-    if let Some(i) = bun_core::strings::index_of_char_usize(specifier, b'?') {
-        let i = i as usize;
+    if let Some(mut i) = bun_core::strings::index_of_char_usize(specifier, b'?') {
+        // A '?' that sits before a path separator is part of a directory name
+        // (POSIX allows '?' in filenames), not a query string. Only split on a
+        // '?' that appears in the final path segment. #7928
+        if bun_core::strings::contains_char(&specifier[i + 1..], b'/') {
+            let base = bun_core::strings::last_index_of_char(specifier, b'/').unwrap_or(0) + 1;
+            match bun_core::strings::index_of_char_usize(&specifier[base..], b'?') {
+                Some(j) => i = base + j,
+                None => return specifier,
+            }
+        }
         *query_string = &specifier[i..];
         &specifier[..i]
     } else {

test/regression/issue/07928.test.ts

@@ -0,0 +1,95 @@
+// https://github.com/oven-sh/bun/issues/7928
+// A '?' in a directory name was being treated as a query-string separator by
+// the module resolver/loader, so files under that directory could not be
+// loaded. Windows does not allow '?' in path names, so these tests only run on
+// POSIX.
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe, isWindows, normalizeBunSnapshot, tempDir } from "harness";
+
+test.skipIf(isWindows)("`bun test` runs tests from a directory whose name contains '?'", async () => {
+  using dir = tempDir("issue-7928-test", {
+    "some-path?/my.test.js": `
+      import { test, expect } from "bun:test";
+      test("inside dir with ?", () => { expect(1 + 1).toBe(2); });
+    `,
+  });
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "test", "my.test.js"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const out = normalizeBunSnapshot(stdout + stderr, dir);
+  expect(out).toContain("(pass) inside dir with ?");
+  expect(out).toContain("1 pass");
+  expect(out).not.toContain("Module not found");
+  expect(out).not.toContain("FileNotFound");
+  expect(exitCode).toBe(0);
+});
+
+test.skipIf(isWindows)("`bun <file>` runs a file under a directory whose name contains '?'", async () => {
+  using dir = tempDir("issue-7928-run", {
+    "some-path?/main.js": `console.log("ran from dir with ?");`,
+  });
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "./some-path?/main.js"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(stderr).toBe("");
+  expect(stdout).toBe("ran from dir with ?\n");
+  expect(exitCode).toBe(0);
+});
+
+test.skipIf(isWindows)("import resolves across a directory whose name contains '?'", async () => {
+  using dir = tempDir("issue-7928-import", {
+    "dir?/dep.js": `export const value = 42;`,
+    "dir?/entry.js": `
+      import { value } from "./dep.js";
+      console.log(JSON.stringify({ value, url: import.meta.url }));
+    `,
+  });
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "./dir?/entry.js"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(stderr).toBe("");
+  const { value, url } = JSON.parse(stdout.trim());
+  expect(value).toBe(42);
+  expect(decodeURIComponent(url)).toEndWith("dir?/entry.js");
+  expect(exitCode).toBe(0);
+});
+
+test.skipIf(isWindows)("query-string suffix still works when a parent directory contains '?'", async () => {
+  using dir = tempDir("issue-7928-query", {
+    "dir?/dep.js": `export const url = import.meta.url;`,
+    "dir?/entry.js": `
+      const a = await import("./dep.js");
+      const b = await import("./dep.js?v=1");
+      console.log(JSON.stringify({ a: a.url, b: b.url, distinct: a !== b }));
+    `,
+  });
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "./dir?/entry.js"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(stderr).toBe("");
+  const { a, b, distinct } = JSON.parse(stdout.trim());
+  expect(decodeURIComponent(a)).toEndWith("dir?/dep.js");
+  expect(decodeURIComponent(b)).toEndWith("dir?/dep.js?v=1");
+  expect(distinct).toBe(true);
+  expect(exitCode).toBe(0);
+});