diff --git a/src/ast/runtime.rs b/src/ast/runtime.rs
index 80fec8848aa6..bb2f3ab00fc2 100644
--- a/src/ast/runtime.rs
+++ b/src/ast/runtime.rs
@@ -175,10 +175,11 @@ pub struct Imports {
     pub __promiseAll: Ref,
     pub __MEMO_CACHE_SENTINEL: Ref,
     pub __EARLY_RETURN_SENTINEL: Ref,
+    pub __glob: Ref,
 }
 
 impl Imports {
-    pub const ALL: [&'static [u8]; 27] = [
+    pub const ALL: [&'static [u8]; 28] = [
         b"__name",
         b"__require",
         b"__export",
@@ -206,12 +207,13 @@ impl Imports {
         b"__promiseAll",
         b"__MEMO_CACHE_SENTINEL",
         b"__EARLY_RETURN_SENTINEL",
+        b"__glob",
     ];
 
     /// Rust stable cannot sort in `const`; precomputed here and verified by
     /// the test in `tests` below.
     #[cfg_attr(not(test), allow(dead_code))]
-    const ALL_SORTED: [&'static [u8]; 27] = [
+    const ALL_SORTED: [&'static [u8]; 28] = [
         b"$$typeof",
         b"__EARLY_RETURN_SENTINEL",
         b"__MEMO_CACHE_SENTINEL",
@@ -222,6 +224,7 @@ impl Imports {
         b"__export",
         b"__exportDefault",
         b"__exportValue",
+        b"__glob",
         b"__jsonParse",
         b"__legacyDecorateClassTS",
         b"__legacyDecorateParamTS",
@@ -243,34 +246,35 @@ impl Imports {
 
     /// When generating the list of runtime imports, we sort it for determinism.
     /// This is a lookup table so we don't need to resort the strings each time
-    pub const ALL_SORTED_INDEX: [usize; 27] = [
-        15, // __name
-        24, // __require
+    pub const ALL_SORTED_INDEX: [usize; 28] = [
+        16, // __name
+        25, // __require
         7,  // __export
-        23, // __reExport
+        24, // __reExport
         9,  // __exportValue
         8,  // __exportDefault
-        14, // __merge
-        11, // __legacyDecorateClassTS
-        12, // __legacyDecorateParamTS
-        13, // __legacyMetadataTS
-        22, // __publicField
-        18, // __privateIn
-        17, // __privateGet
-        16, // __privateAdd
-        20, // __privateSet
-        19, // __privateMethod
+        15, // __merge
+        12, // __legacyDecorateClassTS
+        13, // __legacyDecorateParamTS
+        14, // __legacyMetadataTS
+        23, // __publicField
+        19, // __privateIn
+        18, // __privateGet
+        17, // __privateAdd
+        21, // __privateSet
+        20, // __privateMethod
         6,  // __decoratorStart
         5,  // __decoratorMetadata
-        25, // __runInitializers
+        26, // __runInitializers
         4,  // __decorateElement
         0,  // $$typeof
-        26, // __using
+        27, // __using
         3,  // __callDispose
-        10, // __jsonParse
-        21, // __promiseAll
+        11, // __jsonParse
+        22, // __promiseAll
         2,  // __MEMO_CACHE_SENTINEL
         1,  // __EARLY_RETURN_SENTINEL
+        10, // __glob
     ];
 
     pub const NAME: &'static [u8] = b"bun:wrap";
@@ -306,6 +310,7 @@ impl Imports {
             24 => self.__promiseAll,
             25 => self.__MEMO_CACHE_SENTINEL,
             26 => self.__EARLY_RETURN_SENTINEL,
+            27 => self.__glob,
             _ => return None,
         };
         r.to_nullable()
@@ -341,6 +346,7 @@ impl Imports {
             24 => Some(&mut self.__promiseAll),
             25 => Some(&mut self.__MEMO_CACHE_SENTINEL),
             26 => Some(&mut self.__EARLY_RETURN_SENTINEL),
+            27 => Some(&mut self.__glob),
             _ => None,
         }
     }
diff --git a/src/bundler/ParseTask.rs b/src/bundler/ParseTask.rs
index 86fc7ff7c7e4..5c9257d245f3 100644
--- a/src/bundler/ParseTask.rs
+++ b/src/bundler/ParseTask.rs
@@ -2412,6 +2412,7 @@ pub mod parse_worker {
         // a worker-owned `Transpiler` that outlives the parse.
         // SAFETY: ARENA — `topts` outlives `opts` (worker-owned for the bundle pass).
         opts.allow_unresolved = unsafe { bun_collections::detach_ref(&topts.allow_unresolved) };
+        opts.glob_resolver = Some(crate::options::parser_glob_resolver);
         // `Transpiler.macro_context` is `Option<bun_ast::Macro::MacroContext>`
         // (same nominal type as `ParserOptions.macro_context`'s pointee). Reborrow
         // through the raw `*mut Transpiler` so the `&mut MacroContext` is disjoint
diff --git a/src/bundler/options.rs b/src/bundler/options.rs
index e709614c53eb..52c1ffac139b 100644
--- a/src/bundler/options.rs
+++ b/src/bundler/options.rs
@@ -77,6 +77,47 @@ pub fn validate_path(
 // `&transpiler.options.allow_unresolved` straight through.
 pub use bun_js_parser::options::AllowUnresolved;
 
+/// `glob_resolver` for the parser's template-literal `require()` / `import()`
+/// support: returns each match as a `./`- or `../`-prefixed relative specifier.
+pub fn parser_glob_resolver(source_dir: &[u8], pattern: &[u8]) -> Vec<Box<[u8]>> {
+    let mut out: Vec<Box<[u8]>> = Vec::new();
+    if !(pattern.starts_with(b"./") || pattern.starts_with(b"../")) {
+        return out;
+    }
+
+    let walker = match bun_glob::BunGlobWalker::init_with_cwd(
+        pattern, source_dir, true, false, true, false, true, None,
+    ) {
+        Ok(Ok(w)) => w,
+        _ => return out,
+    };
+    let mut walker = Box::new(walker);
+    let mut iter = bun_glob::walk::Iterator::new(&mut *walker);
+    if iter.init().map(|m| m.is_err()).unwrap_or(true) {
+        return out;
+    }
+    loop {
+        match iter.next() {
+            Ok(Ok(Some(m))) => {
+                let p: &[u8] = &m;
+                let mut s: Vec<u8> = p
+                    .iter()
+                    .map(|&b| if cfg!(windows) && b == b'\\' { b'/' } else { b })
+                    .collect();
+                if !(s.starts_with(b"./") || s.starts_with(b"../")) {
+                    s.splice(0..0, b"./".iter().copied());
+                }
+                out.push(s.into_boxed_slice());
+            }
+            Ok(Ok(None)) => break,
+            // A mid-walk failure would otherwise emit a partial map whose
+            // keys can never cover the runtime specifier.
+            Ok(Err(_)) | Err(_) => return Vec::new(),
+        }
+    }
+    out
+}
+
 // Canonical defs live in `bun_resolver::options` (lower tier; resolver is the
 // runtime consumer of `.patterns`/`.abs_paths`/`.node_modules`). Re-export so
 // `BundleOptions.external` and `Resolver.opts.external` are the SAME nominal
diff --git a/src/bundler/transpiler.rs b/src/bundler/transpiler.rs
index 8fb72a09715a..5102d389a63a 100644
--- a/src/bundler/transpiler.rs
+++ b/src/bundler/transpiler.rs
@@ -1550,6 +1550,7 @@ impl<'a> Transpiler<'a> {
                     macro_context: None,
                     warn_about_unbundled_modules: !target.is_bun(),
                     allow_unresolved: &p_opts::AllowUnresolved::DEFAULT,
+                    glob_resolver: None,
                     module_type: to_parser_module_type(this_parse.module_type),
                     output_format: p_opts::Format::Esm,
                     transform_only: self.options.transform_only,
diff --git a/src/js_parser/p.rs b/src/js_parser/p.rs
index 2a4761ab6141..49de1ed36256 100644
--- a/src/js_parser/p.rs
+++ b/src/js_parser/p.rs
@@ -563,6 +563,10 @@ pub struct P<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> {
 
     pub const_values: bun_ast::ast_result::ConstValuesMap,
 
+    /// `const x = <relative-path template>` initializers, consulted by
+    /// `append_dynamic_specifier_shape` so `require(x)` can glob.
+    pub glob_specifier_values: bun_ast::ast_result::ConstValuesMap,
+
     // These are backed by stack fallback allocators in _parse, and are uninitialized until then.
     pub binary_expression_stack: ListManaged<'a, BinaryExpressionVisitor>,
     // Reusable stack for `SideEffects::simplify_unused_binary_comma_expr`;
@@ -801,28 +805,322 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         arg: Expr,
         buf: &'b mut BumpVec<'a, u8>,
     ) -> Result<&'b [u8], crate::Error> {
-        if let Some(tmpl) = arg.data.e_template() {
-            if tmpl.tag.is_some() {
-                return Ok(b""); // tagged template — opaque
+        if self.append_dynamic_specifier_shape(arg, buf, 0)? {
+            Ok(buf.as_slice())
+        } else {
+            buf.clear();
+            Ok(b"")
+        }
+    }
+
+    fn append_estring_rope(
+        &self,
+        s: &js_ast::e::EString,
+        buf: &mut BumpVec<'a, u8>,
+    ) -> Result<bool, crate::Error> {
+        let start = buf.len();
+        let mut cur: Option<&js_ast::e::EString> = Some(s);
+        while let Some(seg) = cur {
+            let bytes = seg.string(self.arena)?;
+            if bytes.iter().any(|&b| b == 0) {
+                buf.truncate(start);
+                return Ok(false);
+            }
+            buf.extend_from_slice(bytes);
+            cur = seg.next.as_ref().map(|r| r.get());
+        }
+        Ok(true)
+    }
+
+    /// Appends `arg`'s static shape to `buf`; `false` means nothing was
+    /// appended (`buf` is truncated back to its entry length).
+    fn append_dynamic_specifier_shape(
+        &mut self,
+        arg: Expr,
+        buf: &mut BumpVec<'a, u8>,
+        depth: u32,
+    ) -> Result<bool, crate::Error> {
+        if depth >= 32 {
+            return Ok(false);
+        }
+        let start = buf.len();
+        let ok = match &arg.data {
+            js_ast::ExprData::EString(s) => self.append_estring_rope(s, buf)?,
+            js_ast::ExprData::ETemplate(tmpl) => 'tmpl: {
+                if tmpl.tag.is_some() {
+                    break 'tmpl false;
+                }
+                match &tmpl.head {
+                    js_ast::e::TemplateContents::Cooked(head) => {
+                        if !self.append_estring_rope(head, buf)? {
+                            break 'tmpl false;
+                        }
+                    }
+                    js_ast::e::TemplateContents::Raw(_) => break 'tmpl false,
+                }
+                let mut ok = true;
+                for part in tmpl.parts().iter() {
+                    let value = part.value;
+                    if !self.append_dynamic_specifier_shape(value, buf, depth + 1)? {
+                        buf.push(0);
+                    }
+                    match &part.tail {
+                        js_ast::e::TemplateContents::Cooked(tail) => {
+                            if !self.append_estring_rope(tail, buf)? {
+                                ok = false;
+                                break;
+                            }
+                        }
+                        js_ast::e::TemplateContents::Raw(_) => {
+                            ok = false;
+                            break;
+                        }
+                    }
+                }
+                ok
             }
-            match &tmpl.head {
-                js_ast::e::TemplateContents::Cooked(head) => {
-                    buf.extend_from_slice(head.string(self.arena)?);
+            js_ast::ExprData::EBinary(bin) if bin.op == js_ast::Op::Code::BinAdd => {
+                let (l, r) = (bin.left, bin.right);
+                let ok_l = self.append_dynamic_specifier_shape(l, buf, depth + 1)?;
+                if !ok_l {
+                    buf.push(0);
                 }
-                js_ast::e::TemplateContents::Raw(_) => return Ok(b""), // shouldn't happen post-visit but be safe
+                let ok_r = self.append_dynamic_specifier_shape(r, buf, depth + 1)?;
+                if !ok_r {
+                    buf.push(0);
+                }
+                ok_l || ok_r
             }
-            for part in tmpl.parts().iter() {
-                buf.push(0); // \x00 placeholder per interpolation
-                match &part.tail {
-                    js_ast::e::TemplateContents::Cooked(tail) => {
-                        buf.extend_from_slice(tail.string(self.arena)?);
+            js_ast::ExprData::EIdentifier(id) => {
+                let ref_ = id.ref_;
+                if ref_.source_index() == self.source.index.0
+                    && self.symbols[ref_.inner_index() as usize].kind
+                        == js_ast::symbol::Kind::Constant
+                {
+                    if let Some(init) = self.glob_specifier_values.remove(&ref_) {
+                        let r = self.append_dynamic_specifier_shape(init, buf, depth + 1);
+                        self.glob_specifier_values.put(ref_, init).expect("oom");
+                        return r;
                     }
-                    js_ast::e::TemplateContents::Raw(_) => return Ok(b""), // raw tail — treat as opaque
                 }
+                false
+            }
+            _ => false,
+        };
+        if !ok {
+            buf.truncate(start);
+        }
+        Ok(ok)
+    }
+
+    fn glob_shape_is_eligible(shape: &[u8]) -> bool {
+        if !(shape.starts_with(b"./") || shape.starts_with(b"../")) {
+            return false;
+        }
+        if !shape.iter().any(|b| *b == 0) {
+            return false;
+        }
+        match shape.last() {
+            Some(&0) | Some(&b'/') => return false,
+            _ => {}
+        }
+        for &b in shape {
+            if matches!(b, b'*' | b'?' | b'[' | b'{' | b'!' | b'\\') {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// `\x00` placeholders become `**/*` between slashes, `*` otherwise
+    /// (matches esbuild; keeps `./mods/${x}.js` bounded to one directory).
+    fn glob_shape_to_pattern(shape: &[u8], out: &mut Vec<u8>) {
+        out.clear();
+        let mut i = 0;
+        while i < shape.len() {
+            let b = shape[i];
+            if b != 0 {
+                out.push(b);
+                i += 1;
+                continue;
             }
-            return Ok(buf.as_slice());
+            while i < shape.len() && shape[i] == 0 {
+                i += 1;
+            }
+            let left_slash = out.last() == Some(&b'/');
+            let right_slash = shape.get(i) == Some(&b'/');
+            if left_slash && right_slash {
+                out.extend_from_slice(b"**/*");
+            } else {
+                out.push(b'*');
+            }
+        }
+    }
+
+    /// Record `const x = <template>` so `require(x)` can glob. Lookup gates on
+    /// `Kind::Constant`, so non-const entries stored here are simply ignored.
+    pub fn maybe_track_glob_specifier(&mut self, ref_: Ref, value: Option<Expr>) {
+        if self.options.glob_resolver.is_none() {
+            return;
+        }
+        let Some(val) = value else { return };
+        match val.data {
+            js_ast::ExprData::ETemplate(ref t) if t.tag.is_none() => {}
+            js_ast::ExprData::EBinary(ref b) if b.op == js_ast::Op::Code::BinAdd => {}
+            _ => return,
+        }
+        let mut shape_buf = BumpVec::new_in(self.arena);
+        let shape = match self.extract_dynamic_specifier_shape(val, &mut shape_buf) {
+            Ok(s) => s,
+            Err(_) => return,
+        };
+        if shape.starts_with(b"./") || shape.starts_with(b"../") {
+            self.glob_specifier_values.put(ref_, val).expect("oom");
+        }
+    }
+
+    /// Rewrite `require(arg)` with a relative-path template/concat arg into
+    /// `__glob({ "./a.js": () => require("./a.js"), ... })(arg)`.
+    pub fn try_glob_dynamic_require(
+        &mut self,
+        arg: Expr,
+        kind: ImportKind,
+        handles_import_errors: bool,
+    ) -> Option<Expr> {
+        if !self.options.bundle || self.is_control_flow_dead {
+            return None;
+        }
+        let resolver = self.options.glob_resolver?;
+
+        let mut shape_buf = BumpVec::new_in(self.arena);
+        let shape = self
+            .extract_dynamic_specifier_shape(arg, &mut shape_buf)
+            .ok()?;
+        if !Self::glob_shape_is_eligible(shape) {
+            return None;
+        }
+
+        let source_dir = self.source.path.source_dir();
+        if source_dir.is_empty() {
+            return None;
+        }
+
+        let mut pattern = Vec::with_capacity(shape.len() + 4);
+        Self::glob_shape_to_pattern(shape, &mut pattern);
+
+        let mut matches = resolver(source_dir, &pattern);
+        if matches.is_empty() {
+            return None;
+        }
+        const GLOB_MATCH_CAP: usize = 256;
+        if matches.len() > GLOB_MATCH_CAP {
+            return None;
+        }
+        matches.sort();
+        matches.dedup();
+
+        let loc = arg.loc;
+
+        let mut properties: BumpVec<'_, G::Property> =
+            BumpVec::with_capacity_in(matches.len(), self.arena);
+        for m in matches.iter() {
+            let path_bytes: &'a [u8] = self.arena.alloc_slice_copy(m);
+            let path = fs::Path::init(path_bytes);
+            let import_record_index = self.add_import_record_by_range_and_path(
+                kind,
+                self.source.range_of_string(loc),
+                &path,
+            );
+            self.import_records.items_mut()[import_record_index as usize]
+                .flags
+                .set(
+                    bun_ast::ImportRecordFlags::HANDLES_IMPORT_ERRORS,
+                    handles_import_errors,
+                );
+            self.import_records_for_current_part
+                .push(import_record_index);
+
+            let value_expr = if kind == ImportKind::Dynamic {
+                let path_str = self.new_expr(
+                    E::String {
+                        data: path_bytes.into(),
+                        ..Default::default()
+                    },
+                    loc,
+                );
+                self.new_expr(
+                    E::Import {
+                        expr: path_str,
+                        import_record_index,
+                        options: Expr {
+                            loc,
+                            data: js_ast::ExprData::EMissing(E::Missing {}),
+                        },
+                    },
+                    loc,
+                )
+            } else {
+                self.new_expr(
+                    E::RequireString {
+                        import_record_index,
+                        ..Default::default()
+                    },
+                    loc,
+                )
+            };
+
+            let ret_stmt = self.s(
+                S::Return {
+                    value: Some(value_expr),
+                },
+                loc,
+            );
+            let body_stmts = self.arena.alloc_slice_copy(&[ret_stmt]);
+            let thunk = self.new_expr(
+                E::Arrow {
+                    args: bun_ast::StoreSlice::EMPTY,
+                    body: G::FnBody {
+                        loc,
+                        stmts: body_stmts.into(),
+                    },
+                    prefer_expr: true,
+                    ..Default::default()
+                },
+                loc,
+            );
+
+            let key = self.new_expr(
+                E::String {
+                    data: path_bytes.into(),
+                    ..Default::default()
+                },
+                loc,
+            );
+            properties.push(G::Property {
+                key: Some(key),
+                value: Some(thunk),
+                ..Default::default()
+            });
         }
-        Ok(b"")
+
+        let map_obj = self.new_expr(
+            E::Object {
+                properties: G::PropertyList::from_bump_vec(properties),
+                ..Default::default()
+            },
+            loc,
+        );
+
+        let glob_call = self.call_runtime(loc, b"__glob", ExprNodeList::init_one(map_obj));
+
+        Some(self.new_expr(
+            E::Call {
+                target: glob_call,
+                args: ExprNodeList::init_one(arg),
+                ..Default::default()
+            },
+            loc,
+        ))
     }
 
     pub fn check_dynamic_specifier(
@@ -1003,6 +1301,15 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             );
         }
 
+        if matches!(state.import_options.data, js_ast::ExprData::EMissing(..)) {
+            let handles = (state.is_await_target
+                && self.fn_or_arrow_data_visit.try_body_count != 0)
+                || state.is_then_catch_target;
+            if let Some(glob) = self.try_glob_dynamic_require(arg, ImportKind::Dynamic, handles) {
+                return glob;
+            }
+        }
+
         if self.options.warn_about_unbundled_modules {
             // Use a debug log so people can see this if they want to
             let r = js_lexer::range_of_identifier(self.source, state.loc);
@@ -1223,6 +1530,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 )
             }
             _ => {
+                let handles = self.fn_or_arrow_data_visit.try_body_count != 0;
+                if let Some(glob) = self.try_glob_dynamic_require(arg, ImportKind::Require, handles)
+                {
+                    return glob;
+                }
                 let _ = self.check_dynamic_specifier(arg, arg.loc, "require()");
                 self.record_usage_of_runtime_require();
                 self.new_expr(
@@ -8797,6 +9109,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             relocated_top_level_vars: BumpVec::new_in(arena),
             after_arrow_body_loc: bun_ast::Loc::EMPTY,
             const_values: Default::default(),
+            glob_specifier_values: Default::default(),
             binary_expression_stack: BumpVec::new_in(arena),
             binary_expression_simplify_stack: BumpVec::new_in(arena),
             ref_to_ts_namespace_member: Default::default(),
diff --git a/src/js_parser/parse/parse_entry.rs b/src/js_parser/parse/parse_entry.rs
index 9227cd63a118..70cede93e7f3 100644
--- a/src/js_parser/parse/parse_entry.rs
+++ b/src/js_parser/parse/parse_entry.rs
@@ -84,6 +84,10 @@ pub struct Options<'a> {
 
     pub allow_unresolved: &'a options::AllowUnresolved,
 
+    /// Enables the `__glob({...})(arg)` rewrite for template-literal
+    /// `require()`/`import()`.
+    pub glob_resolver: Option<options::GlobResolver>,
+
     pub module_type: options::ModuleType,
     pub output_format: options::Format,
 
@@ -127,6 +131,7 @@ impl<'a> Default for Options<'a> {
             macro_context: None,
             warn_about_unbundled_modules: true,
             allow_unresolved: &options::AllowUnresolved::DEFAULT,
+            glob_resolver: None,
             module_type: options::ModuleType::Unknown,
             output_format: options::Format::Esm,
             transform_only: false,
@@ -210,6 +215,7 @@ impl<'a> Options<'a> {
             macro_context: None,
             warn_about_unbundled_modules: self.warn_about_unbundled_modules,
             allow_unresolved: self.allow_unresolved,
+            glob_resolver: self.glob_resolver,
             module_type: self.module_type,
             output_format: self.output_format,
             transform_only: self.transform_only,
@@ -277,6 +283,7 @@ impl<'a> Options<'a> {
             macro_context: None,
             warn_about_unbundled_modules: true,
             allow_unresolved: &options::AllowUnresolved::DEFAULT,
+            glob_resolver: None,
             module_type: options::ModuleType::Unknown,
             output_format: options::Format::Esm,
             transform_only: false,
diff --git a/src/js_parser/parser.rs b/src/js_parser/parser.rs
index bc841052ca24..e7e996446b74 100644
--- a/src/js_parser/parser.rs
+++ b/src/js_parser/parser.rs
@@ -59,6 +59,10 @@ pub mod options {
     /// is captured.
     pub(crate) type AllowUnresolvedMatcher = fn(pattern: &[u8], shape: &[u8]) -> bool;
 
+    /// Filesystem glob for template-literal `require()`/`import()`; injected
+    /// by the bundler since the parser cannot depend on `bun_glob`.
+    pub type GlobResolver = fn(source_dir: &[u8], pattern: &[u8]) -> Vec<Box<[u8]>>;
+
     #[derive(Debug, Clone, Default)]
     pub enum AllowUnresolved {
         /// Default. Skip all checks — current behavior.
diff --git a/src/js_parser/visit/mod.rs b/src/js_parser/visit/mod.rs
index a88147dfc3d0..00a5ca096874 100644
--- a/src/js_parser/visit/mod.rs
+++ b/src/js_parser/visit/mod.rs
@@ -543,6 +543,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 } else {
                     self.vis_scope().is_after_const_local_prefix = true;
                 }
+                self.maybe_track_glob_specifier(id_ref, decl.value);
                 // SAFETY: original_name is arena-owned, valid for 'a.
                 let original_name: &'a [u8] = self.symbols[id_ref.inner_index() as usize]
                     .original_name
diff --git a/src/js_parser/visit/visit_expr.rs b/src/js_parser/visit/visit_expr.rs
index fa3efcb7c061..3730bca9e34b 100644
--- a/src/js_parser/visit/visit_expr.rs
+++ b/src/js_parser/visit/visit_expr.rs
@@ -2033,7 +2033,15 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         *e = p.transpose_known_to_be_if_require(first, &state);
                         return;
                     }
-                    _ => {}
+                    _ => {
+                        let handles = p.fn_or_arrow_data_visit.try_body_count != 0;
+                        if let Some(glob) =
+                            p.try_glob_dynamic_require(first, bun_ast::ImportKind::Require, handles)
+                        {
+                            *e = glob;
+                            return;
+                        }
+                    }
                 }
             }
 
diff --git a/src/runtime.js b/src/runtime.js
index 7f0501db97c7..d078e593a04c 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -109,6 +109,15 @@ var __moduleCache;
 // When you do know the module is CJS
 export var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
+// Lookup table for template-literal require()/import(); throws MODULE_NOT_FOUND on miss.
+export var __glob = map => path => {
+  var fn = map[path];
+  if (fn) return fn();
+  var e = new Error("Cannot find module '" + path + "' in glob import map. Available: " + Object.keys(map).join(", "));
+  e.code = "MODULE_NOT_FOUND";
+  throw e;
+};
+
 export var __name = (target, name) => {
   Object.defineProperty(target, "name", {
     value: name,
diff --git a/test/bundler/__snapshots__/bun-build-api.test.ts.snap b/test/bundler/__snapshots__/bun-build-api.test.ts.snap
index a3e5110281b9..7003254d70d4 100644
--- a/test/bundler/__snapshots__/bun-build-api.test.ts.snap
+++ b/test/bundler/__snapshots__/bun-build-api.test.ts.snap
@@ -66,11 +66,11 @@ NS.then(({ fn: fn2 }) => {
 "
 `;
 
-exports[`Bun.build BuildArtifact properties: hash 1`] = `"est79qzq"`;
+exports[`Bun.build BuildArtifact properties: hash 1`] = `"bgsev3fg"`;
 
-exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"7gfnt0h6"`;
+exports[`Bun.build BuildArtifact properties + entry.naming: hash 1`] = `"1vbevqqk"`;
 
-exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"est79qzq"`;
+exports[`Bun.build BuildArtifact properties sourcemap: hash index.js 1`] = `"bgsev3fg"`;
 
 exports[`Bun.build BuildArtifact properties sourcemap: hash index.js.map 1`] = `"00000000"`;
 
diff --git a/test/bundler/bundler_glob_require.test.ts b/test/bundler/bundler_glob_require.test.ts
new file mode 100644
index 000000000000..8b5bb11b770d
--- /dev/null
+++ b/test/bundler/bundler_glob_require.test.ts
@@ -0,0 +1,341 @@
+import { describe } from "bun:test";
+import { itBundled } from "./expectBundled";
+
+// esbuild-style glob imports: `require()` / `import()` whose argument is a
+// relative-path template literal bundles every file matching the pattern and
+// dispatches at runtime via a __glob({...}) lookup table.
+//
+// Also covers the `const specifier = <template>; require(specifier)` shape,
+// which is how many native-addon loaders (e.g. tigerbeetle-node, issue #9951)
+// pick a platform-specific .node file.
+describe("bundler", () => {
+  itBundled("glob-require/TemplateLiteralDirect", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const which = process.env.WHICH;
+        console.log(require(\`./mods/\${which}.js\`));
+      `,
+      "/mods/a.js": `module.exports = "value-a";`,
+      "/mods/b.js": `module.exports = "value-b";`,
+    },
+    run: [
+      { env: { WHICH: "a" }, stdout: "value-a" },
+      { env: { WHICH: "b" }, stdout: "value-b" },
+    ],
+    onAfterBundle(api) {
+      const out = api.readFile("/out.js");
+      api.expectFile("/out.js").toContain("__glob");
+      api.expectFile("/out.js").toContain('"./mods/a.js"');
+      api.expectFile("/out.js").toContain('"./mods/b.js"');
+      if (out.includes("import.meta.require")) {
+        throw new Error("expected template-literal require to be bundled, not deferred to runtime");
+      }
+    },
+  });
+
+  itBundled("glob-require/TemplateLiteralMiss", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const which = process.env.WHICH || "c";
+        try {
+          require(\`./mods/\${which}.js\`);
+        } catch (e) {
+          console.log(e.code, e.message);
+        }
+      `,
+      "/mods/a.js": `module.exports = 1;`,
+      "/mods/b.js": `module.exports = 2;`,
+    },
+    run: {
+      stdout:
+        "MODULE_NOT_FOUND Cannot find module './mods/c.js' in glob import map. Available: ./mods/a.js, ./mods/b.js",
+    },
+  });
+
+  itBundled("glob-require/StringConcatenation", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const which = process.env.WHICH;
+        console.log(require("./mods/" + which + ".js"));
+      `,
+      "/mods/a.js": `module.exports = "concat-a";`,
+      "/mods/b.js": `module.exports = "concat-b";`,
+    },
+    run: { env: { WHICH: "b" }, stdout: "concat-b" },
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain("__glob");
+    },
+  });
+
+  // Adjacent string literals are folded into a rope EString before the glob
+  // check; the shape extractor must read every segment.
+  itBundled("glob-require/StringConcatenationAdjacentLiterals", {
+    target: "bun",
+    minifySyntax: true,
+    files: {
+      "/entry.js": /* js */ `
+        const which = process.env.WHICH;
+        console.log(require("./mods" + "/" + which + ".js"));
+      `,
+      "/mods/a.js": `module.exports = "rope-a";`,
+      "/mods/b.js": `module.exports = "rope-b";`,
+    },
+    run: { env: { WHICH: "a" }, stdout: "rope-a" },
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain('"./mods/a.js"');
+    },
+  });
+
+  // A self-referential const must not send the bundler into unbounded
+  // recursion. The self-reference contributes a placeholder, so a map is
+  // still emitted; the entry throws TDZ at runtime before the lookup.
+  itBundled("glob-require/SelfReferentialConst", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        try {
+          const a = \`./mods/\${a}.js\`;
+          require(a);
+        } catch (e) {
+          console.log("caught");
+        }
+      `,
+      "/mods/x.js": `module.exports = 1;`,
+    },
+    run: { stdout: "caught" },
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain('"./mods/x.js"');
+    },
+  });
+
+  // A literal NUL in a template's static content must not be confused with
+  // the placeholder marker.
+  itBundled("glob-require/LiteralNulNotGlobbed", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const which = process.env.WHICH || "a";
+        try { require(\`./mods/\\0\${which}.js\`); } catch {}
+        console.log("ok");
+      `,
+      "/mods/a.js": `module.exports = 1;`,
+    },
+    run: { stdout: "ok" },
+    onAfterBundle(api) {
+      const out = api.readFile("/out.js");
+      if (out.includes("__glob")) {
+        throw new Error("literal NUL must not be treated as a glob placeholder");
+      }
+    },
+  });
+
+  // import() with a second argument (import attributes) is not glob-resolved;
+  // it falls through to the runtime import so the attributes are preserved.
+  itBundled("glob-require/DynamicImportWithOptionsNotGlobbed", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const which = process.env.WHICH || "a";
+        const m = await import(\`./mods/\${which}.json\`, { with: { type: "json" } });
+        void m;
+        console.log("ok");
+      `,
+      "/mods/a.json": `{"a":1}`,
+    },
+    onAfterBundle(api) {
+      const out = api.readFile("/out.js");
+      if (out.includes("__glob")) {
+        throw new Error("import() with attributes must not be glob-resolved");
+      }
+    },
+  });
+
+  itBundled("glob-require/ConstIndirection", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const which = process.env.WHICH;
+        const specifier = \`./mods/\${which}.js\`;
+        console.log(require(specifier));
+      `,
+      "/mods/a.js": `module.exports = "indirect-a";`,
+      "/mods/b.js": `module.exports = "indirect-b";`,
+    },
+    run: { env: { WHICH: "a" }, stdout: "indirect-a" },
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain("__glob");
+    },
+  });
+
+  // A `let` binding may be reassigned, so the bundler must not treat its
+  // initializer as the specifier shape.
+  itBundled("glob-require/LetIndirectionNotBundled", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        let specifier = \`./mods/\${process.env.WHICH}.js\`;
+        if (process.env.OVERRIDE) specifier = process.env.OVERRIDE;
+        try { require(specifier); } catch {}
+        console.log("ok");
+      `,
+      "/mods/a.js": `module.exports = 1;`,
+    },
+    run: { stdout: "ok" },
+    onAfterBundle(api) {
+      const out = api.readFile("/out.js");
+      if (out.includes("__glob")) {
+        throw new Error("let-bound specifier should not be glob-resolved");
+      }
+    },
+  });
+
+  // Zero matches falls through to runtime require (same as before), so
+  // bundling still succeeds and the call can be caught at runtime.
+  itBundled("glob-require/ZeroMatchesFallsThrough", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        try {
+          require(\`./nowhere/\${process.env.X}.js\`);
+        } catch (e) {
+          console.log("caught");
+        }
+      `,
+    },
+    run: { stdout: "caught" },
+    onAfterBundle(api) {
+      const out = api.readFile("/out.js");
+      if (out.includes("__glob")) {
+        throw new Error("zero-match glob should fall through, not emit __glob");
+      }
+    },
+  });
+
+  itBundled("glob-require/DynamicImport", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const which = process.env.WHICH;
+        const m = await import(\`./mods/\${which}.js\`);
+        console.log(m.default);
+      `,
+      "/mods/a.js": `export default "import-a";`,
+      "/mods/b.js": `export default "import-b";`,
+    },
+    run: { env: { WHICH: "b" }, stdout: "import-b" },
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain("__glob");
+    },
+  });
+
+  itBundled("glob-require/SubdirectoryMatch", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const plat = process.env.PLAT;
+        console.log(require(\`./bin/\${plat}/client.js\`));
+      `,
+      "/bin/x64-linux/client.js": `module.exports = "linux";`,
+      "/bin/arm64-darwin/client.js": `module.exports = "darwin";`,
+      "/bin/README.md": `not js`,
+    },
+    run: [
+      { env: { PLAT: "x64-linux" }, stdout: "linux" },
+      { env: { PLAT: "arm64-darwin" }, stdout: "darwin" },
+    ],
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain('"./bin/x64-linux/client.js"');
+      api.expectFile("/out.js").toContain('"./bin/arm64-darwin/client.js"');
+      api.expectFile("/out.js").not.toContain("README");
+    },
+  });
+
+  // The tigerbeetle-node pattern: a const specifier built from several
+  // interpolations, declared after control flow that computes one of the
+  // pieces, inside an IIFE.
+  itBundled("glob-require/NativeAddonLoaderPattern", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        const binding = (() => {
+          const { PLAT, ARCH } = process.env;
+          let extra = "";
+          if (PLAT === "linux") extra = "-gnu";
+          const filename = \`./bin/\${ARCH}-\${PLAT}\${extra}/client.js\`;
+          return require(filename);
+        })();
+        console.log(binding);
+      `,
+      "/bin/x64-linux-gnu/client.js": `module.exports = "linux-gnu";`,
+      "/bin/x64-darwin/client.js": `module.exports = "darwin";`,
+      "/bin/arm64-darwin/client.js": `module.exports = "arm-darwin";`,
+    },
+    run: [
+      { env: { PLAT: "linux", ARCH: "x64" }, stdout: "linux-gnu" },
+      { env: { PLAT: "darwin", ARCH: "x64" }, stdout: "darwin" },
+      { env: { PLAT: "darwin", ARCH: "arm64" }, stdout: "arm-darwin" },
+    ],
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain("__glob");
+      api.expectFile("/out.js").toContain('"./bin/x64-linux-gnu/client.js"');
+    },
+  });
+
+  // The #9951 scenario end to end: a platform-specific .node addon required
+  // via a const template specifier is embedded in a --compile binary. We use
+  // dummy addon bytes so the test does not need node-gyp; loading is expected
+  // to fail at dlopen time, which is past the point the glob resolution and
+  // asset embedding this PR adds have both succeeded.
+  itBundled("glob-require/CompileEmbedsNodeAddon", {
+    compile: true,
+    target: "bun",
+    files: {
+      "/entry.ts": /* js */ `
+        const binding = (() => {
+          const plat = process.env.PLAT || "x64-linux";
+          const filename = \`./bin/\${plat}/client.node\`;
+          try {
+            return require(filename);
+          } catch (e) {
+            // Embedding worked when we got as far as trying to dlopen the
+            // dummy bytes; a resolver miss would be MODULE_NOT_FOUND instead.
+            if (e.code === "ERR_DLOPEN_FAILED") return "dlopen-attempted";
+            throw e;
+          }
+        })();
+        const names = Bun.embeddedFiles.map(f => f.name).sort();
+        console.log(JSON.stringify({ binding, count: names.length }));
+      `,
+      "/bin/x64-linux/client.node": Buffer.from("not a real addon"),
+      "/bin/arm64-darwin/client.node": Buffer.from("not a real addon either"),
+    },
+    run: {
+      setCwd: true,
+      env: { PLAT: "x64-linux" },
+      stdout: JSON.stringify({ binding: "dlopen-attempted", count: 2 }),
+    },
+  });
+
+  // Bare specifiers (no `./` / `../`) must not be globbed.
+  itBundled("glob-require/BareSpecifierNotGlobbed", {
+    target: "bun",
+    files: {
+      "/entry.js": /* js */ `
+        try {
+          require(\`some-pkg/\${process.env.X}\`);
+        } catch {}
+        console.log("ok");
+      `,
+    },
+    run: { stdout: "ok" },
+    onAfterBundle(api) {
+      const out = api.readFile("/out.js");
+      if (out.includes("__glob")) {
+        throw new Error("bare specifiers must not be glob-resolved");
+      }
+    },
+  });
+});
diff --git a/test/bundler/bundler_promiseall_deadcode.test.ts b/test/bundler/bundler_promiseall_deadcode.test.ts
index 46c1ac38b7da..1f907533bd8f 100644
--- a/test/bundler/bundler_promiseall_deadcode.test.ts
+++ b/test/bundler/bundler_promiseall_deadcode.test.ts
@@ -164,7 +164,7 @@ describe("bundler", () => {
         var { AsyncEntryPoint: AsyncEntryPoint2 } = await Promise.resolve().then(() => exports_AsyncEntryPoint);
         AsyncEntryPoint2();
 
-        //# debugId=42062903F19477CF64756E2164756E21
+        //# debugId=7141FE02CB0F22E264756E2164756E21
         //# sourceMappingURL=out.js.map
         "
       `);
@@ -410,7 +410,7 @@ describe("bundler", () => {
         var { AsyncEntryPoint: AsyncEntryPoint2 } = await Promise.resolve().then(() => exports_AsyncEntryPoint);
         AsyncEntryPoint2();
 
-        //# debugId=BF876FBF618133C264756E2164756E21
+        //# debugId=02B60B4FF92A818164756E2164756E21
         //# sourceMappingURL=out.js.map
         "
       `);
diff --git a/test/bundler/html-import-manifest.test.ts b/test/bundler/html-import-manifest.test.ts
index fbcf26e91598..74215705e8b4 100644
--- a/test/bundler/html-import-manifest.test.ts
+++ b/test/bundler/html-import-manifest.test.ts
@@ -106,11 +106,11 @@ console.log(favicon);
             "files": [
               {
                 "input": "client.html",
-                "path": "./client-sjg7egv9.js",
+                "path": "./client-m110bjd9.js",
                 "loader": "js",
                 "isEntry": true,
                 "headers": {
-                  "etag": "efKwB-6QGwk",
+                  "etag": "VOGhIOsSzQk",
                   "content-type": "text/javascript;charset=utf-8"
                 }
               },
@@ -120,7 +120,7 @@ console.log(favicon);
                 "loader": "html",
                 "isEntry": true,
                 "headers": {
-                  "etag": "sJJm55rxM4I",
+                  "etag": "-sM_LDk0GTo",
                   "content-type": "text/html;charset=utf-8"
                 }
               },
diff --git a/test/regression/issue/cyclic-imports-async-bundler.test.js b/test/regression/issue/cyclic-imports-async-bundler.test.js
index baf7cfd6ca87..906b5a14f799 100644
--- a/test/regression/issue/cyclic-imports-async-bundler.test.js
+++ b/test/regression/issue/cyclic-imports-async-bundler.test.js
@@ -180,7 +180,7 @@ test("cyclic imports with async dependencies should generate async wrappers", as
     var { AsyncEntryPoint: AsyncEntryPoint2 } = await Promise.resolve().then(() => exports_AsyncEntryPoint);
     AsyncEntryPoint2();
 
-    //# debugId=2020261114B67BB564756E2164756E21
+    //# debugId=37EEE4862DD2283364756E2164756E21
     //# sourceMappingURL=entryBuild.js.map
     "
   `);