Fix TanStack Start compatibility

crates/perry-codegen/src/lower_call/extern_func.rs

@@ -1350,7 +1350,11 @@ pub fn try_lower_extern_func_call(
         // scope in #689 and continue to fall through to `js_jsx`; the runtime
         // returns `undefined` for those unrecognised intrinsic sentinels until
         // the rewriter is extended.
-        "jsx" | "jsxs" => {
+        "jsx" | "jsxs"
+            if !ctx.imported_vars.contains(name)
+                && !ctx.import_function_prefixes.contains_key(name)
+                && !ctx.import_function_v8_specifiers.contains_key(name) =>
+        {
             if let Some(call) = try_rewrite_perry_tui_jsx_intrinsic(ctx, name == "jsxs", args)? {
                 return Ok(Some(call));
             }

crates/perry-hir/src/dynamic_import/visitors.rs

@@ -437,6 +437,13 @@ fn visit_expr_for_dyn_imports_ref<F: FnMut(&Expr)>(expr: &Expr, f: &mut F) {
     if matches!(expr, Expr::DynamicImport { .. }) {
         f(expr);
     }
+    // Closure bodies — mirror the mutable visitor so the collect pass and the
+    // fill pass traverse dynamic import sites in the same order.
+    if let Expr::Closure { body, .. } = expr {
+        for s in body {
+            visit_stmt_for_dyn_imports_ref(s, f);
+        }
+    }
     walk_expr_children(expr, &mut |child| visit_expr_for_dyn_imports_ref(child, f));
 }
 

crates/perry-hir/src/jsx.rs

@@ -13,7 +13,8 @@ use crate::lower::{lower_expr, LoweringContext};
 pub(crate) fn lower_jsx_element(ctx: &mut LoweringContext, jsx: &ast::JSXElement) -> Result<Expr> {
     let type_expr = lower_jsx_element_name(ctx, &jsx.opening.name)?;
 
-    let mut props_fields: Vec<(String, Expr)> = Vec::new();
+    let mut props_parts: Vec<(Option<String>, Expr)> = Vec::new();
+    let mut has_spread_attr = false;
     for attr in &jsx.opening.attrs {
         match attr {
             ast::JSXAttrOrSpread::JSXAttr(jsx_attr) => {
@@ -31,12 +32,11 @@ pub(crate) fn lower_jsx_element(ctx: &mut LoweringContext, jsx: &ast::JSXElement
                     None => Expr::Bool(true), // Boolean attribute: <input disabled />
                     Some(val) => lower_jsx_attr_value(ctx, val)?,
                 };
-                props_fields.push((attr_name, attr_val));
+                props_parts.push((Some(attr_name), attr_val));
             }
             ast::JSXAttrOrSpread::SpreadElement(spread) => {
-                // Spread attributes ({...obj}) are not yet representable in HIR Object.
-                // Evaluate for side effects but don't propagate into props.
-                let _ = lower_expr(ctx, &spread.expr);
+                has_spread_attr = true;
+                props_parts.push((None, lower_expr(ctx, &spread.expr)?));
             }
         }
     }
@@ -54,17 +54,24 @@ pub(crate) fn lower_jsx_element(ctx: &mut LoweringContext, jsx: &ast::JSXElement
     match children.len() {
         0 => {}
         1 => {
-            props_fields.push(("children".to_string(), children.remove(0)));
+            props_parts.push((Some("children".to_string()), children.remove(0)));
         }
         _ => {
-            props_fields.push(("children".to_string(), Expr::Array(children)));
+            props_parts.push((Some("children".to_string()), Expr::Array(children)));
         }
     }
 
-    let props_expr = if props_fields.is_empty() {
+    let props_expr = if props_parts.is_empty() {
         Expr::Null
+    } else if has_spread_attr {
+        Expr::ObjectSpread { parts: props_parts }
     } else {
-        Expr::Object(props_fields)
+        Expr::Object(
+            props_parts
+                .into_iter()
+                .map(|(key, value)| (key.expect("non-spread JSX prop"), value))
+                .collect(),
+        )
     };
 
     // #4950: a module that default-imports the npm `react` package gets
@@ -176,9 +183,26 @@ pub(crate) fn lower_jsx_fragment(
             }),
             property: "Fragment".to_string(),
         };
-        if let Some(call) = react_create_element_call(ctx, fragment_type, &props_expr) {
-            return Ok(call);
-        }
+        return Ok(Expr::Call {
+            callee: Box::new(Expr::PropertyGet {
+                object: Box::new(if let Some(id) = ctx.lookup_local(&react_local) {
+                    Expr::LocalGet(id)
+                } else {
+                    Expr::ExternFuncRef {
+                        name: ctx
+                            .lookup_imported_func(&react_local)
+                            .unwrap_or(&react_local)
+                            .to_string(),
+                        param_types: Vec::new(),
+                        return_type: Type::Any,
+                    }
+                }),
+                property: "createElement".to_string(),
+            }),
+            args: vec![fragment_type, props_expr],
+            type_args: Vec::new(),
+            byte_offset: 0,
+        });
     }
 
     Ok(Expr::Call {
@@ -187,17 +211,12 @@ pub(crate) fn lower_jsx_fragment(
             param_types: Vec::new(),
             return_type: Type::Any,
         }),
-        // Fragment marker: inline "__Fragment" string. perry-react's jsx() checks
-        // `type === "__Fragment"` to detect fragment elements.
         args: vec![Expr::String("__Fragment".to_string()), props_expr],
         type_args: Vec::new(),
         byte_offset: 0,
     })
 }
 
-/// Lower a JSX element name to an HIR expression.
-/// Lowercase tag names (HTML intrinsics) become string literals.
-/// Uppercase tag names (components) are looked up as identifiers.
 pub(crate) fn lower_jsx_element_name(
     ctx: &mut LoweringContext,
     name: &ast::JSXElementName,

crates/perry-hir/src/lower/expr_function.rs

@@ -28,6 +28,9 @@ use crate::lower_patterns::{
     generate_param_destructuring_stmts, get_param_default, get_pat_name, get_pat_type,
     is_destructuring_pattern, is_rest_param,
 };
+use crate::lower_types::hoisted_text_codec::{
+    infer_hoisted_text_codec_var_type, require_literal_specifier,
+};
 
 use super::{lower_expr, LoweringContext};
 
@@ -735,6 +738,7 @@ fn lower_fn_expr_anon(ctx: &mut LoweringContext, fn_expr: &ast::FnExpr) -> Resul
     // #4950: undefined-initialised `Stmt::Let`s for `var`s found nested in
     // compound statements — prepended to the lowered body below.
     let mut nested_var_prologue: Vec<Stmt> = Vec::new();
+    let mut top_level_var_prologue: Vec<Stmt> = Vec::new();
     if let Some(ref block) = fn_expr.function.body {
         // Issue #838 followup (b): pre-register top-level `var` decls in
         // this function body BEFORE lowering any statement. dayjs's
@@ -752,6 +756,7 @@ fn lower_fn_expr_anon(ctx: &mut LoweringContext, fn_expr: &ast::FnExpr) -> Resul
         // shared synthetic class id on the instance and dispatch finds
         // the prototype methods. Same shallow-walk policy as the
         // codegen-side `referenced_from_fn` pre-scan.
+        let mut builtin_aliases_in_var_decl = std::collections::HashSet::new();
         for stmt in &block.stmts {
             if let ast::Stmt::Decl(ast::Decl::Var(var_decl)) = stmt {
                 if var_decl.kind == ast::VarDeclKind::Var {
@@ -774,12 +779,41 @@ fn lower_fn_expr_anon(ctx: &mut LoweringContext, fn_expr: &ast::FnExpr) -> Resul
                             &decl.name, &mut names,
                         );
                         for name in names {
+                            let ty = if let ast::Pat::Ident(ident) = &decl.name {
+                                if decl.init.as_deref().and_then(require_literal_specifier)
+                                    == Some("util")
+                                    || decl.init.as_deref().and_then(require_literal_specifier)
+                                        == Some("node:util")
+                                {
+                                    builtin_aliases_in_var_decl.insert(name.clone());
+                                }
+                                infer_hoisted_text_codec_var_type(decl, ident, |name| {
+                                    builtin_aliases_in_var_decl.contains(name)
+                                        || matches!(
+                                            ctx.lookup_builtin_module_alias(name),
+                                            Some("util" | "node:util")
+                                        )
+                                        || matches!(
+                                            ctx.lookup_native_module(name),
+                                            Some(("util" | "node:util", None))
+                                        )
+                                })
+                            } else {
+                                Type::Any
+                            };
                             let already_in_scope = ctx
                                 .locals
                                 .lookup_index_in_scope(&name, outer_locals_len)
                                 .is_some();
                             if !already_in_scope {
-                                let id = ctx.define_local(name, Type::Any);
+                                let id = ctx.define_local(name.clone(), ty.clone());
+                                top_level_var_prologue.push(Stmt::Let {
+                                    id,
+                                    name,
+                                    ty,
+                                    mutable: true,
+                                    init: Some(Expr::Undefined),
+                                });
                                 // Mark as hoisted so closures created
                                 // before the var's init expression see
                                 // it through a box (mutable capture),
@@ -1090,8 +1124,13 @@ fn lower_fn_expr_anon(ctx: &mut LoweringContext, fn_expr: &ast::FnExpr) -> Resul
                     _ => exec_stmts.extend(lowered),
                 }
             }
-            let mut combined: Vec<Stmt> =
-                Vec::with_capacity(nested_var_prologue.len() + func_decls.len() + exec_stmts.len());
+            let mut combined: Vec<Stmt> = Vec::with_capacity(
+                top_level_var_prologue.len()
+                    + nested_var_prologue.len()
+                    + func_decls.len()
+                    + exec_stmts.len(),
+            );
+            combined.extend(std::mem::take(&mut top_level_var_prologue));
             // Nested-var undefined slots first so every later read/write —
             // including from hoisted function-declaration closures — sees
             // initialised storage (#4950).

crates/perry-hir/src/lower/lower_module_fn.rs

@@ -14,6 +14,77 @@ use swc_ecma_ast as ast;
 
 use super::*;
 use crate::ir::*;
+use crate::lower_types::hoisted_text_codec::{
+    infer_hoisted_text_codec_var_type, require_literal_specifier,
+};
+
+fn should_enable_react_automatic_jsx(name: &str, ast_module: &ast::Module) -> bool {
+    let is_jsx_source = name.ends_with(".tsx")
+        || name.ends_with(".jsx")
+        || name.contains(".tsx?")
+        || name.contains(".jsx?");
+    if !is_jsx_source {
+        return false;
+    }
+
+    let mut has_explicit_react_import = false;
+    let mut has_react_ecosystem_import = false;
+    for item in &ast_module.body {
+        let ast::ModuleItem::ModuleDecl(ast::ModuleDecl::Import(import)) = item else {
+            continue;
+        };
+        let source = import.src.value.to_string_lossy().to_string();
+        if source == "react" && import_has_runtime_binding(import) {
+            has_explicit_react_import = true;
+        }
+        if source.starts_with("@tanstack/react-")
+            || source == "@tanstack/react-router"
+            || source == "react/jsx-runtime"
+        {
+            has_react_ecosystem_import = true;
+        }
+    }
+
+    if has_explicit_react_import {
+        return false;
+    }
+
+    has_react_ecosystem_import
+        || name.contains("node_modules/@tanstack/react-")
+        || name.contains("node_modules/@tanstack/react-router/")
+}
+
+fn import_has_runtime_binding(import: &ast::ImportDecl) -> bool {
+    if import.type_only {
+        return false;
+    }
+    import.specifiers.iter().any(|spec| match spec {
+        ast::ImportSpecifier::Named(named) => !named.is_type_only,
+        ast::ImportSpecifier::Default(_) | ast::ImportSpecifier::Namespace(_) => true,
+    })
+}
+
+fn enable_react_automatic_jsx(module: &mut Module, ctx: &mut LoweringContext) {
+    const LOCAL: &str = "__perry_react_auto";
+    let local = LOCAL.to_string();
+    ctx.register_imported_func(local.clone(), local.clone());
+    ctx.namespace_import_locals.insert(local.clone());
+    ctx.namespace_import_sources
+        .insert(local.clone(), "react".to_string());
+    ctx.react_default_import_local = Some(local.clone());
+    module.imports.push(Import {
+        source: "react".to_string(),
+        specifiers: vec![ImportSpecifier::Namespace { local }],
+        is_native: false,
+        module_kind: ModuleKind::NativeCompiled,
+        resolved_path: None,
+        type_only: false,
+        is_dynamic: false,
+        is_dynamic_target: false,
+        is_deferred_require: false,
+        is_adopted_require: false,
+    });
+}
 
 fn module_has_strict_mode(ast_module: &ast::Module) -> bool {
     for item in &ast_module.body {
@@ -355,6 +426,9 @@ pub fn lower_module_full(
         ctx.seed_imported_class_accessors(seed);
     }
     let mut module = Module::new(name);
+    if should_enable_react_automatic_jsx(name, ast_module) {
+        enable_react_automatic_jsx(&mut module, &mut ctx);
+    }
 
     // Pre-scan for `new Function` / `Function(...)` constant-argument
     // resolution: single-assignment module vars, `toString`-bearing object
@@ -536,6 +610,7 @@ pub fn lower_module_full(
             _ => None,
         };
         if let Some(var_decl) = var_decl {
+            let mut builtin_aliases_in_decl = HashSet::new();
             for decl in &var_decl.decls {
                 // #4461: `var X = class { ... }` is lowered as a class
                 // expression bound to the name `X` (see stmt.rs) — the class
@@ -551,12 +626,24 @@ pub fn lower_module_full(
                 }
                 if let ast::Pat::Ident(ident) = &decl.name {
                     let name = ident.id.sym.to_string();
+                    if decl.init.as_deref().and_then(require_literal_specifier) == Some("util")
+                        || decl.init.as_deref().and_then(require_literal_specifier)
+                            == Some("node:util")
+                    {
+                        builtin_aliases_in_decl.insert(name.clone());
+                    }
                     if ctx.lookup_local(&name).is_none() {
-                        let ty = ident
-                            .type_ann
-                            .as_ref()
-                            .map(|ann| extract_ts_type(&ann.type_ann))
-                            .unwrap_or(Type::Any);
+                        let ty = infer_hoisted_text_codec_var_type(decl, ident, |name| {
+                            builtin_aliases_in_decl.contains(name)
+                                || matches!(
+                                    ctx.lookup_builtin_module_alias(name),
+                                    Some("util" | "node:util")
+                                )
+                                || matches!(
+                                    ctx.lookup_native_module(name),
+                                    Some(("util" | "node:util", None))
+                                )
+                        });
                         ctx.define_local(name.clone(), ty);
                         ctx.pre_registered_module_vars.insert(name);
                         if var_decl.kind == ast::VarDeclKind::Var {

crates/perry-hir/src/lower/module_decl.rs

@@ -391,7 +391,7 @@ pub(crate) fn lower_module_decl(
                             // so JSX in this module lowers to
                             // `<local>.createElement(...)` instead of Perry's
                             // eager `js_jsx` adapter (see jsx.rs).
-                            if source == "react" {
+                            if source == "react" && !whole_decl_type_only {
                                 ctx.react_default_import_local = Some(local.clone());
                             }
                         }
@@ -422,6 +422,15 @@ pub(crate) fn lower_module_decl(
                             // not lower to StaticMethodCall — see the heuristic
                             // in expr_call::static_and_instance.
                             ctx.namespace_import_locals.insert(local.clone());
+                            // React namespace imports are the common TSX shape
+                            // (`import * as React from "react"`). They need the
+                            // same non-eager React element semantics as default
+                            // React imports; Perry's native JSX adapter calls
+                            // function components immediately and therefore runs
+                            // hooks outside the reconciler.
+                            if source == "react" && !whole_decl_type_only {
+                                ctx.react_default_import_local = Some(local.clone());
+                            }
                             // Remember the source so a later bare `export { local }`
                             // re-exports the namespace itself rather than a bare
                             // function symbol (see the local-export branch below).

crates/perry-hir/src/lower_types.rs

@@ -276,6 +276,8 @@ const INFER_TYPE_RECURSION_CAP: u32 = 48;
 const INFER_TYPE_STACK_RED_ZONE: usize = 256 * 1024;
 const INFER_TYPE_STACK_SEGMENT: usize = 2 * 1024 * 1024;
 
+pub(crate) mod hoisted_text_codec;
+
 pub(crate) fn infer_type_from_expr(expr: &ast::Expr, ctx: &LoweringContext) -> Type {
     thread_local! {
         static INFER_DEPTH: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };