ai slop

src/ast/loader.rs

@@ -100,6 +100,15 @@ bun_core::comptime_string_map! {
     };
 }
 
+/// TypeScript declaration files: `foo.d.ts`, `foo.d.mts`, `foo.d.cts`.
+/// Matches the file-name rule tsc uses (`isDeclarationFileName`), minus the
+/// rare `.d.*.ts` arbitrary-extension form.
+pub fn is_type_script_declaration_file(path: &[u8]) -> bool {
+    bun_core::strings::has_suffix_comptime(path, b".d.ts")
+        || bun_core::strings::has_suffix_comptime(path, b".d.mts")
+        || bun_core::strings::has_suffix_comptime(path, b".d.cts")
+}
+
 impl Loader {
     #[inline]
     pub fn is_css(self) -> bool {

src/bundler/ParseTask.rs

@@ -2395,6 +2395,8 @@ pub mod parse_worker {
             loader,
         );
         opts.bundle = true;
+        opts.typescript_declaration_file = loader.is_typescript()
+            && bun_ast::loader::is_type_script_declaration_file(source.path.text);
         opts.warn_about_unbundled_modules = false;
         // `AllowUnresolved` is the same nominal type on
         // both sides (re-export in options.rs). `'static` erasure: `topts` borrows

src/bundler/bundle_v2.rs

@@ -2194,12 +2194,31 @@ pub mod bv2_impl {
 
             let mut had_busted_dir_cache = false;
             let resolve_result: _resolver::Result = loop {
-                // SAFETY: see `transpiler` note above.
-                match unsafe { &mut *transpiler }.resolver.resolve(
-                    source_dir,
-                    &import_record.specifier,
-                    import_record.kind,
-                ) {
+                // Declaration-file importers resolve like tsc does (see
+                // `Resolver::importer_is_type_script_declaration_file`). Set
+                // only for the duration of the call; the flag is per-resolve
+                // state.
+                let resolved = {
+                    // SAFETY: see `transpiler` note above.
+                    unsafe { &mut *transpiler }
+                        .resolver
+                        .importer_is_type_script_declaration_file =
+                        bun_ast::loader::is_type_script_declaration_file(
+                            &import_record.source_file,
+                        );
+                    // SAFETY: see `transpiler` note above.
+                    let r = unsafe { &mut *transpiler }.resolver.resolve(
+                        source_dir,
+                        &import_record.specifier,
+                        import_record.kind,
+                    );
+                    // SAFETY: see `transpiler` note above.
+                    unsafe { &mut *transpiler }
+                        .resolver
+                        .importer_is_type_script_declaration_file = false;
+                    r
+                };
+                match resolved {
                     Ok(r) => break r,
                     Err(err) => {
                         // Only perform directory busting when hot-reloading is enabled
@@ -6063,11 +6082,22 @@ pub mod bv2_impl {
 
                 let mut had_busted_dir_cache = false;
                 let resolve_result: _resolver::Result = 'inner: loop {
-                    match transpiler.resolver.resolve_with_framework(
-                        source_dir,
-                        import_record.path.text,
-                        import_record.kind,
-                    ) {
+                    // Declaration-file importers resolve like tsc does (see
+                    // `Resolver::importer_is_type_script_declaration_file`).
+                    // Set only for the duration of the call; the flag is
+                    // per-resolve state.
+                    let resolved = {
+                        transpiler.resolver.importer_is_type_script_declaration_file =
+                            bun_ast::loader::is_type_script_declaration_file(source.path.text);
+                        let r = transpiler.resolver.resolve_with_framework(
+                            source_dir,
+                            import_record.path.text,
+                            import_record.kind,
+                        );
+                        transpiler.resolver.importer_is_type_script_declaration_file = false;
+                        r
+                    };
+                    match resolved {
                         Ok(r) => break r,
                         Err(err) => {
                             // borrowck — `log_for_resolution_failures` returns

src/bundler/options.rs

@@ -713,6 +713,11 @@ pub struct ESMConditions {
     pub(crate) import: ConditionsMap,
     pub(crate) require: ConditionsMap,
     pub(crate) style: ConditionsMap,
+    /// `import` / `require` plus the "types" condition, used when the
+    /// importer is a TypeScript declaration file so bare specifiers resolve
+    /// to a package's declaration entry the way tsc resolves them.
+    pub(crate) import_types: ConditionsMap,
+    pub(crate) require_types: ConditionsMap,
 }
 
 impl ESMConditions {
@@ -763,11 +768,18 @@ impl ESMConditions {
         require_condition_map.insert(b"default".as_slice(), ());
         style_condition_map.insert(b"default".as_slice(), ());
 
+        let mut import_types_condition_map = import_condition_map.clone()?;
+        import_types_condition_map.insert(b"types".as_slice(), ());
+        let mut require_types_condition_map = require_condition_map.clone()?;
+        require_types_condition_map.insert(b"types".as_slice(), ());
+
         Ok(ESMConditions {
             default: default_condition_amp,
             import: import_condition_map,
             require: require_condition_map,
             style: style_condition_map,
+            import_types: import_types_condition_map,
+            require_types: require_types_condition_map,
         })
     }
 
@@ -776,12 +788,16 @@ impl ESMConditions {
         let import = self.import.clone()?;
         let require = self.require.clone()?;
         let style = self.style.clone()?;
+        let import_types = self.import_types.clone()?;
+        let require_types = self.require_types.clone()?;
 
         Ok(ESMConditions {
             default,
             import,
             require,
             style,
+            import_types,
+            require_types,
         })
     }
 
@@ -790,12 +806,16 @@ impl ESMConditions {
         self.import.reserve(conditions.len());
         self.require.reserve(conditions.len());
         self.style.reserve(conditions.len());
+        self.import_types.reserve(conditions.len());
+        self.require_types.reserve(conditions.len());
 
         for condition in conditions {
             self.default.insert(*condition, ());
             self.import.insert(*condition, ());
             self.require.insert(*condition, ());
             self.style.insert(*condition, ());
+            self.import_types.insert(*condition, ());
+            self.require_types.insert(*condition, ());
         }
         Ok(())
     }
@@ -1438,6 +1458,8 @@ impl<'a> BundleOptions<'a> {
                 import: bun_core::handle_oom(self.conditions.import.clone()),
                 require: bun_core::handle_oom(self.conditions.require.clone()),
                 style: bun_core::handle_oom(self.conditions.style.clone()),
+                import_types: bun_core::handle_oom(self.conditions.import_types.clone()),
+                require_types: bun_core::handle_oom(self.conditions.require_types.clone()),
             },
             tree_shaking: self.tree_shaking,
             tree_shaking_override: self.tree_shaking_override,
@@ -1692,6 +1714,8 @@ impl<'a> BundleOptions<'a> {
                 import: Default::default(),
                 require: Default::default(),
                 style: Default::default(),
+                import_types: Default::default(),
+                require_types: Default::default(),
             }, // filled below
             tree_shaking: false,
             tree_shaking_override: None,

src/bundler/transpiler.rs

@@ -1075,6 +1075,8 @@ fn resolver_bundle_options_subset(
             import: src.conditions.import.clone().expect("oom"),
             require: src.conditions.require.clone().expect("oom"),
             style: src.conditions.style.clone().expect("oom"),
+            import_types: src.conditions.import_types.clone().expect("oom"),
+            require_types: src.conditions.require_types.clone().expect("oom"),
         },
         external: src.external.clone(),
         extra_cjs_extensions: src.extra_cjs_extensions.clone(),
@@ -1536,6 +1538,8 @@ impl<'a> Transpiler<'a> {
                 use js_ast::parser::options as p_opts;
                 let mut opts = js_ast::ParserOptions::<'_> {
                     ts: loader.is_typescript(),
+                    typescript_declaration_file: loader.is_typescript()
+                        && bun_ast::loader::is_type_script_declaration_file(source.path.text),
                     jsx: to_parser_jsx_pragma(jsx),
                     keep_names: true,
                     ignore_dce_annotations: self.options.ignore_dce_annotations,

src/js_parser/p.rs

@@ -345,6 +345,17 @@ pub struct P<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> {
     pub(crate) is_exported_inside_namespace: RefRefMap,
     pub(crate) local_type_names: StringBoolMap,
 
+    /// Declaration-file mode (`options.typescript_declaration_file`): names of
+    /// module-scope type-only declarations (type aliases, interfaces,
+    /// `declare` statements) in source order, so the end of the parse pass can
+    /// synthesize `var` bindings for them. The map value records whether the
+    /// declaration was exported.
+    pub(crate) dts_type_names: StringBoolMap,
+    pub(crate) dts_type_name_order: Vec<&'a [u8]>,
+    /// True while parsing a `declare global { ... }` body, which shares the
+    /// module-scope `ParseStatementOptions` but must not synthesize bindings.
+    pub(crate) dts_suppress_type_name_recording: bool,
+
     // This is the reference to the generated function argument for the namespace,
     // which is different than the reference to the namespace itself:
     //
@@ -4529,6 +4540,87 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         ref_
     }
 
+    /// Declaration-file mode: remember a module-scope type-only declaration's
+    /// name so `synthesize_declaration_file_bindings` can emit a `var` for it
+    /// at the end of the parse pass.
+    pub(crate) fn record_declaration_file_type_name(
+        &mut self,
+        name: &'a [u8],
+        is_export: bool,
+    ) -> Result<(), crate::Error> {
+        if !Self::IS_TYPESCRIPT_ENABLED
+            || !self.options.typescript_declaration_file
+            || self.dts_suppress_type_name_recording
+            || !js_lexer::is_identifier(name)
+        {
+            return Ok(());
+        }
+        match self.dts_type_names.get(name) {
+            Some(&prev_is_export) => {
+                if is_export && !prev_is_export {
+                    self.dts_type_names.put(name, true)?;
+                }
+            }
+            None => {
+                self.dts_type_names.put(name, is_export)?;
+                self.dts_type_name_order.push(name);
+            }
+        }
+        Ok(())
+    }
+
+    /// Declaration-file mode: synthesize `var` bindings (bound to undefined)
+    /// for the type-only declarations recorded during the parse pass, so the
+    /// module record exposes every name the declaration file declares and
+    /// re-export chains through declaration files link. Names that already
+    /// have a real binding (declaration merging, imports) are skipped.
+    pub(crate) fn synthesize_declaration_file_bindings(
+        &mut self,
+        stmts: &mut BumpVec<'a, Stmt>,
+    ) -> Result<(), crate::Error> {
+        if self.dts_type_name_order.is_empty() {
+            return Ok(());
+        }
+        debug_assert!(self.current_scope == self.module_scope);
+        let names = core::mem::take(&mut self.dts_type_name_order);
+        let mut exported_decls: Vec<G::Decl> = Vec::new();
+        let mut local_decls: Vec<G::Decl> = Vec::new();
+        for name in names {
+            if self.current_scope().members.contains_key(name) {
+                continue;
+            }
+            let is_export = self.dts_type_names.get(name).copied().unwrap_or(false);
+            let ref_ =
+                self.declare_symbol(js_ast::symbol::Kind::Hoisted, bun_ast::Loc::EMPTY, name)?;
+            let decl = G::Decl {
+                binding: self.b(B::Identifier { r#ref: ref_ }, bun_ast::Loc::EMPTY),
+                value: None,
+            };
+            if is_export {
+                exported_decls.push(decl);
+            } else {
+                local_decls.push(decl);
+            }
+        }
+        for (decls, is_export) in [(exported_decls, true), (local_decls, false)] {
+            if decls.is_empty() {
+                continue;
+            }
+            let decls = js_ast::g::DeclList::from_slice(&decls);
+            let stmt = self.s(
+                S::Local {
+                    kind: js_ast::s::Kind::KVar,
+                    decls,
+                    is_export,
+                    ..Default::default()
+                },
+                bun_ast::Loc::EMPTY,
+            );
+            stmts.push(stmt);
+        }
+        Ok(())
+    }
+
     pub(crate) fn declare_symbol(
         &mut self,
         kind: js_ast::symbol::Kind,
@@ -4657,7 +4749,16 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         match &mut binding.data {
             js_ast::b::B::BMissing(_) => {}
             js_ast::b::B::BIdentifier(bind) => {
-                if !opts.is_typescript_declare || (opts.is_namespace_scope && opts.is_export) {
+                // Declaration files keep module-scope `declare var/let/const`
+                // bindings as real symbols; the statement is converted to a
+                // `var` in `parse_stmt_fallthrough_ts_keyword`.
+                if !opts.is_typescript_declare
+                    || (opts.is_namespace_scope && opts.is_export)
+                    || (Self::IS_TYPESCRIPT_ENABLED
+                        && self.options.typescript_declaration_file
+                        && opts.is_module_scope
+                        && !self.dts_suppress_type_name_recording)
+                {
                     bind.r#ref = self.declare_symbol(
                         kind,
                         binding.loc,
@@ -8789,6 +8890,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             emitted_namespace_vars: RefMap::default(),
             is_exported_inside_namespace: Default::default(),
             local_type_names: StringBoolMap::default(),
+            dts_type_names: StringBoolMap::default(),
+            dts_type_name_order: Vec::new(),
+            dts_suppress_type_name_recording: false,
             enclosing_namespace_arg_ref: None,
             jsx_imports: crate::JSXImportSymbols::default(),
             react_refresh: ReactRefresh::default(),

src/js_parser/parse/mod.rs

@@ -652,6 +652,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     ) -> Result<Stmt, Error> {
         let p = self;
         let mut name: Option<js_ast::LocRef> = None;
+        let mut name_text: &'a [u8] = b"";
         let class_keyword = p.lexer.range();
         if p.lexer.token == T::TClass {
             //marksyntaxfeature
@@ -667,7 +668,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 && (!Self::IS_TYPESCRIPT_ENABLED || p.lexer.identifier != b"implements"))
         {
             let name_loc = p.lexer.loc();
-            let name_text = p.lexer.identifier;
+            name_text = p.lexer.identifier;
             p.lexer.expect(T::TIdentifier)?;
 
             // We must return here
@@ -727,6 +728,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     p.has_non_local_export_declare_inside_namespace = true;
                 }
 
+                if opts.is_module_scope && !name_text.is_empty() {
+                    p.record_declaration_file_type_name(name_text, opts.is_export)?;
+                }
+
                 return Ok(p.s(S::TypeScript {}, loc));
             }
         }