@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_compile/src/types.rs

@@ -4,7 +4,7 @@
 
 use std::collections::HashMap;
 use std::sync::Arc;
-use tishlang_ast::{BinOp, TypeAnnotation};
+use tishlang_ast::{BinOp, FunParam, TypeAnnotation, TypedParam};
 
 /// Concrete Rust type representation for code generation.
 #[derive(Debug, Clone, PartialEq)]
@@ -23,8 +23,19 @@ pub enum RustType {
     Vec(Box<RustType>),
     /// Option<T> for nullable types (T | null)
     Option(Box<RustType>),
-    /// Rc<RefCell<HashMap<Arc<str>, T>>> for typed objects
+    /// Inline object shape — used during inference / annotation lowering
+    /// before a `Named` alias has been registered. Once a corresponding
+    /// `type Foo = { ... }` declaration is found in the program, occurrences
+    /// of this shape can be canonicalised into `RustType::Named("Foo")`.
     Object(Vec<(Arc<str>, RustType)>),
+    /// User-defined named type (a struct emitted by the compiler).
+    /// The field list is duplicated here so the codegen can emit struct
+    /// literals, member access, and Value-conversion glue without going
+    /// back to a global registry on every call site.
+    Named {
+        name: Arc<str>,
+        fields: Vec<(Arc<str>, RustType)>,
+    },
     /// Fn trait for typed functions
     Function {
         params: Vec<RustType>,
@@ -33,8 +44,21 @@ pub enum RustType {
 }
 
 impl RustType {
-    /// Convert a TypeAnnotation to a RustType.
+    /// Convert a TypeAnnotation to a RustType (no alias resolution).
+    /// Use [`Self::from_annotation_with_aliases`] when a registry is
+    /// available so user-defined `type X = { ... }` aliases land as
+    /// `RustType::Named` and can drive struct emission.
     pub fn from_annotation(ann: &TypeAnnotation) -> Self {
+        Self::from_annotation_with_aliases(ann, &HashMap::new())
+    }
+
+    /// Like [`from_annotation`], but consults `aliases` so a `Simple(name)`
+    /// reference to a user-declared `type X = { ... }` resolves to a
+    /// `RustType::Named { name, fields }` carrying the struct shape.
+    pub fn from_annotation_with_aliases(
+        ann: &TypeAnnotation,
+        aliases: &HashMap<String, RustType>,
+    ) -> Self {
         match ann {
             TypeAnnotation::Simple(name) => match name.as_ref() {
                 "number" => RustType::F64,
@@ -43,21 +67,38 @@ impl RustType {
                 "void" | "undefined" => RustType::Unit,
                 "null" => RustType::Unit,
                 "any" => RustType::Value,
-                _ => RustType::Value, // Unknown types fall back to Value
+                other => {
+                    // User-declared `type X = { ... }`: lift the inline
+                    // object shape into a `Named` so the codegen can emit
+                    // a Rust struct and direct field access for it.
+                    if let Some(t) = aliases.get(other) {
+                        if let RustType::Object(fields) = t {
+                            return RustType::Named {
+                                name: Arc::from(other),
+                                fields: fields.clone(),
+                            };
+                        }
+                        return t.clone();
+                    }
+                    RustType::Value
+                }
             },
-            TypeAnnotation::Array(elem) => {
-                RustType::Vec(Box::new(Self::from_annotation(elem)))
-            }
+            TypeAnnotation::Array(elem) => RustType::Vec(Box::new(
+                Self::from_annotation_with_aliases(elem, aliases),
+            )),
             TypeAnnotation::Object(fields) => {
                 let typed_fields: Vec<_> = fields
                     .iter()
-                    .map(|(k, v)| (k.clone(), Self::from_annotation(v)))
+                    .map(|(k, v)| (k.clone(), Self::from_annotation_with_aliases(v, aliases)))
                     .collect();
                 RustType::Object(typed_fields)
             }
             TypeAnnotation::Function { params, returns } => {
-                let typed_params: Vec<_> = params.iter().map(Self::from_annotation).collect();
-                let typed_returns = Box::new(Self::from_annotation(returns));
+                let typed_params: Vec<_> = params
+                    .iter()
+                    .map(|p| Self::from_annotation_with_aliases(p, aliases))
+                    .collect();
+                let typed_returns = Box::new(Self::from_annotation_with_aliases(returns, aliases));
                 RustType::Function {
                     params: typed_params,
                     returns: typed_returns,
@@ -66,15 +107,17 @@ impl RustType {
             TypeAnnotation::Union(types) => {
                 // Check for T | null pattern -> Option<T>
                 if types.len() == 2 {
-                    let has_null = types.iter().any(|t| {
-                        matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null")
-                    });
+                    let has_null = types
+                        .iter()
+                        .any(|t| matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"));
                     if has_null {
-                        let non_null = types.iter().find(|t| {
-                            !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null")
-                        });
+                        let non_null = types.iter().find(
+                            |t| !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"),
+                        );
                         if let Some(inner) = non_null {
-                            return RustType::Option(Box::new(Self::from_annotation(inner)));
+                            return RustType::Option(Box::new(
+                                Self::from_annotation_with_aliases(inner, aliases),
+                            ));
                         }
                     }
                 }
@@ -132,9 +175,11 @@ impl RustType {
             RustType::Vec(inner) => format!("Vec<{}>", inner.to_rust_type_str()),
             RustType::Option(inner) => format!("Option<{}>", inner.to_rust_type_str()),
             RustType::Object(_) => {
-                // For now, typed objects still use Value
+                // Anonymous inline shapes don't have a Rust struct; fall
+                // back to the dynamic Value path.
                 "Value".to_string()
             }
+            RustType::Named { name, .. } => named_struct_ident(name),
             RustType::Function { params, returns } => {
                 let params_str: Vec<_> = params.iter().map(|p| p.to_rust_type_str()).collect();
                 format!(
@@ -157,6 +202,23 @@ impl RustType {
             RustType::Vec(_) => "Vec::new()".to_string(),
             RustType::Option(_) => "None".to_string(),
             RustType::Object(_) => "Value::Null".to_string(),
+            RustType::Named { fields, .. } => {
+                // Build a literal struct with each field at its own default,
+                // so unannotated decls of a typed struct still compile.
+                let init = fields
+                    .iter()
+                    .map(|(k, t)| format!("{}: {}", field_ident(k), t.default_value()))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!(
+                    "{} {{ {} }}",
+                    named_struct_ident(match self {
+                        RustType::Named { name, .. } => name,
+                        _ => unreachable!(),
+                    }),
+                    init
+                )
+            }
             RustType::Function { .. } => "Value::Null".to_string(),
         }
     }
@@ -192,6 +254,22 @@ impl RustType {
                     value_expr, inner_conversion
                 )
             }
+            RustType::Named { name, fields } => {
+                // Each field is fetched out of the Value::Object via
+                // `get_prop` and converted to its native type. Falls back
+                // to the field's `default_value()` if the field is absent
+                // (rare — usually these come from JSON or PG).
+                let field_assigns = fields
+                    .iter()
+                    .map(|(k, ty)| {
+                        let fetch =
+                            format!("tishlang_runtime::get_prop(&{}, {:?})", value_expr, k.as_ref());
+                        format!("{}: {}", field_ident(k), ty.from_value_expr(&fetch))
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("{} {{ {} }}", named_struct_ident(name), field_assigns)
+            }
             _ => value_expr.to_string(), // Fallback
         }
     }
@@ -212,7 +290,7 @@ impl RustType {
                     _ => (".iter().cloned()", inner.to_value_expr("v")),
                 };
                 format!(
-                    "Value::Array(Rc::new(RefCell::new({}{}.map(|v| {}).collect())))",
+                    "Value::Array(VmRef::new({}{}.map(|v| {}).collect()))",
                     native_expr, iter_suffix, val_expr
                 )
             }
@@ -223,11 +301,57 @@ impl RustType {
                     native_expr, inner_to_value
                 )
             }
+            RustType::Named { fields, .. } => {
+                // Walk fields, build an ObjectMap, wrap in Value::Object.
+                // The boundary is paid only when crossing into untyped
+                // Tish (JSON.stringify, calling a Value::Function, etc.);
+                // direct Rust-to-Rust paths between two Named values stay
+                // as plain struct moves.
+                let inserts = fields
+                    .iter()
+                    .map(|(k, ty)| {
+                        let access = format!("{}.{}", native_expr, field_ident(k));
+                        let v_expr = ty.to_value_expr(&access);
+                        format!(
+                            "_om.insert(::std::sync::Arc::from({:?}), {});",
+                            k.as_ref(),
+                            v_expr
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(" ");
+                format!(
+                    "{{ let mut _om = ObjectMap::default(); {} Value::Object(VmRef::new(_om)) }}",
+                    inserts
+                )
+            }
             _ => native_expr.to_string(), // Fallback
         }
     }
 }
 
+/// Map a Tish type-alias name to the Rust struct identifier we emit.
+/// Prefixed so user names can never collide with runtime types like `Value`.
+pub fn named_struct_ident(tish_name: &str) -> String {
+    format!("TishStruct_{}", tish_name)
+}
+
+/// Map a Tish field name (`randomNumber`) to a valid Rust identifier
+/// (kept identical here — non-snake-case is allowed via
+/// `#[allow(non_snake_case)]` on the struct, so JS-style camelCase keys
+/// stay readable in the generated source).
+pub fn field_ident(tish_name: &str) -> String {
+    // Reserve Rust keywords that would otherwise conflict.
+    match tish_name {
+        "type" | "ref" | "fn" | "match" | "move" | "mod" | "self" | "Self" | "super" | "use"
+        | "where" | "loop" | "yield" | "async" | "await" | "dyn" | "impl" | "trait" | "in"
+        | "as" | "box" | "crate" | "const" | "extern" | "let" | "mut" | "pub" | "static"
+        | "unsafe" | "abstract" | "become" | "do" | "final" | "macro" | "override" | "priv"
+        | "typeof" | "unsized" | "virtual" => format!("r#{}", tish_name),
+        _ => tish_name.to_string(),
+    }
+}
+
 /// Type context for tracking variable types during code generation.
 #[derive(Debug, Clone, Default)]
 pub struct TypeContext {
@@ -252,6 +376,23 @@ impl TypeContext {
         self.scopes.pop();
     }
 
+    /// Push a scope for a function or arrow body and record formals as [`RustType::Value`].
+    ///
+    /// Native codegen always binds parameters from `args.get(i)` as `Value`; this prevents
+    /// outer locals (e.g. a loop counter inferred as [`RustType::F64`]) from shadowing the
+    /// wrong type for the same identifier.
+    pub fn push_fun_param_scope(&mut self, params: &[FunParam], rest_param: Option<&TypedParam>) {
+        self.push_scope();
+        for p in params {
+            for name in p.bound_names() {
+                self.define(name.as_ref(), RustType::Value);
+            }
+        }
+        if let Some(rp) = rest_param {
+            self.define(rp.name.as_ref(), RustType::Value);
+        }
+    }
+
     /// Define a variable in the current scope.
     pub fn define(&mut self, name: &str, ty: RustType) {
         if let Some(scope) = self.scopes.last_mut() {
@@ -271,9 +412,7 @@ impl TypeContext {
 
     /// Check if a variable is typed (has a non-Value type).
     pub fn is_typed(&self, name: &str) -> bool {
-        self.lookup(name)
-            .map(|ty| ty.is_native())
-            .unwrap_or(false)
+        self.lookup(name).map(|ty| ty.is_native()).unwrap_or(false)
     }
 
     /// Get the type of a variable, defaulting to Value if not found.
@@ -329,13 +468,34 @@ mod tests {
         ctx.define("x", RustType::F64);
         assert_eq!(ctx.get_type("x"), RustType::F64);
         assert!(ctx.is_typed("x"));
-        
+
         ctx.push_scope();
         ctx.define("y", RustType::String);
         assert_eq!(ctx.get_type("y"), RustType::String);
         assert_eq!(ctx.get_type("x"), RustType::F64); // Can still see outer scope
-        
+
         ctx.pop_scope();
         assert_eq!(ctx.get_type("y"), RustType::Value); // y no longer visible
     }
+
+    #[test]
+    fn push_fun_param_scope_shadows_outer() {
+        use tishlang_ast::{FunParam, Span, TypedParam};
+
+        let mut ctx = TypeContext::new();
+        ctx.define("n", RustType::F64);
+        let params = vec![FunParam::Simple(TypedParam {
+            name: "n".into(),
+            name_span: Span {
+                start: (0, 0),
+                end: (0, 0),
+            },
+            type_ann: None,
+            default: None,
+        })];
+        ctx.push_fun_param_scope(&params, None);
+        assert_eq!(ctx.get_type("n"), RustType::Value);
+        ctx.pop_scope();
+        assert_eq!(ctx.get_type("n"), RustType::F64);
+    }
 }

package/crates/tish_compile_js/Cargo.toml

@@ -10,6 +10,7 @@ repository = { workspace = true }
 default = []
 
 [dependencies]
+sourcemap = "9.3"
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }

package/crates/tish_compile_js/src/codegen.rs

@@ -1,5 +1,8 @@
 //! Code generation: AST -> JavaScript source.
 
+use std::path::{Path, PathBuf};
+
+use sourcemap::SourceMapBuilder;
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr,
     FunParam, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, UnaryOp,
@@ -16,7 +19,9 @@ struct Codegen {
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
     matches!(
         stmt,
-        Some(Statement::Break { .. }) | Some(Statement::Return { .. }) | Some(Statement::Throw { .. })
+        Some(Statement::Break { .. })
+            | Some(Statement::Return { .. })
+            | Some(Statement::Throw { .. })
     )
 }
 
@@ -43,6 +48,10 @@ impl Codegen {
         self.output.push('\n');
     }
 
+    fn output_line(&self) -> u32 {
+        self.output.as_bytes().iter().filter(|&&b| b == b'\n').count() as u32
+    }
+
     fn escape_ident(s: &str) -> String {
         let s = s.to_string();
         if s == "await" || s == "default" {
@@ -52,10 +61,46 @@ impl Codegen {
         }
     }
 
-    fn emit_program(&mut self, program: &Program) -> Result<(), CompileError> {
+    fn emit_program(
+        &mut self,
+        program: &Program,
+        map_sources: Option<(&[PathBuf], &Path)>,
+        map_builder: Option<&mut SourceMapBuilder>,
+    ) -> Result<(), CompileError> {
         self.write("// Generated by tishlang_compile_js\n");
-        for stmt in &program.statements {
-            self.emit_statement(stmt)?;
+        match (map_sources, map_builder) {
+            (Some((srcs, root)), Some(sm)) => {
+                for (i, stmt) in program.statements.iter().enumerate() {
+                    if i < srcs.len() {
+                        let dst_line = self.output_line();
+                        let sp = stmt.span();
+                        let src_line = sp.start.0.saturating_sub(1) as u32;
+                        let src_col = sp.start.1.saturating_sub(1) as u32;
+                        let abs = srcs[i].as_path();
+                        let root_canon = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());
+                        let abs_canon = abs.canonicalize().unwrap_or_else(|_| abs.to_path_buf());
+                        let rel = abs_canon
+                            .strip_prefix(&root_canon)
+                            .unwrap_or(abs_canon.as_path());
+                        let rel_str = rel.to_string_lossy();
+                        sm.add(
+                            dst_line,
+                            0,
+                            src_line,
+                            src_col,
+                            Some(rel_str.as_ref()),
+                            None,
+                            false,
+                        );
+                    }
+                    self.emit_statement(stmt)?;
+                }
+            }
+            _ => {
+                for stmt in &program.statements {
+                    self.emit_statement(stmt)?;
+                }
+            }
         }
         Ok(())
     }
@@ -174,7 +219,12 @@ impl Codegen {
                 self.emit_statement(body)?;
                 self.indent -= 1;
             }
-            Statement::ForOf { name, iterable, body, .. } => {
+            Statement::ForOf {
+                name,
+                iterable,
+                body,
+                ..
+            } => {
                 let escaped = Self::escape_ident(name.as_ref());
                 let it = self.emit_expr(iterable)?;
                 self.writeln(&format!("for (const {} of {})", escaped, it));
@@ -204,7 +254,10 @@ impl Codegen {
                 let async_prefix = if *async_ { "async " } else { "" };
                 let escaped = Self::escape_ident(name.as_ref());
                 let params_str = self.emit_params(params, rest_param.as_ref())?;
-                self.writeln(&format!("{}function {} ({}) {{", async_prefix, escaped, params_str));
+                self.writeln(&format!(
+                    "{}function {} ({}) {{",
+                    async_prefix, escaped, params_str
+                ));
                 self.indent += 1;
                 if *async_ {
                     self.in_async = true;
@@ -291,6 +344,9 @@ impl Codegen {
             Statement::Import { .. } | Statement::Export { .. } => {
                 // Resolved away by merge_modules
             }
+            Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. } => {}
         }
         Ok(())
     }
@@ -337,11 +393,9 @@ impl Codegen {
                 let parts: Vec<String> = elements
                     .iter()
                     .map(|el| match el {
-                        Some(DestructElement::Ident(n)) => {
-                            Ok(Self::escape_ident(n.as_ref()))
-                        }
+                        Some(DestructElement::Ident(n, _)) => Ok(Self::escape_ident(n.as_ref())),
                         Some(DestructElement::Pattern(p)) => self.emit_destruct_pattern(p),
-                        Some(DestructElement::Rest(n)) => {
+                        Some(DestructElement::Rest(n, _)) => {
                             Ok(format!("...{}", Self::escape_ident(n.as_ref())))
                         }
                         None => Ok("".to_string()),
@@ -355,7 +409,7 @@ impl Codegen {
                     .map(|p| {
                         let k = p.key.as_ref();
                         match &p.value {
-                            DestructElement::Ident(n) => {
+                            DestructElement::Ident(n, _) => {
                                 if k == n.as_ref() {
                                     Ok(k.to_string())
                                 } else {
@@ -365,7 +419,7 @@ impl Codegen {
                             DestructElement::Pattern(pat) => {
                                 Ok(format!("{}: {}", k, self.emit_destruct_pattern(pat)?))
                             }
-                            DestructElement::Rest(n) => {
+                            DestructElement::Rest(n, _) => {
                                 Ok(format!("...{}", Self::escape_ident(n.as_ref())))
                             }
                         }
@@ -385,7 +439,9 @@ impl Codegen {
                 Literal::Null => "null".to_string(),
             },
             Expr::Ident { name, .. } => Self::escape_ident(name.as_ref()),
-            Expr::Binary { left, op, right, .. } => {
+            Expr::Binary {
+                left, op, right, ..
+            } => {
                 let l = self.emit_expr(left)?;
                 let r = self.emit_expr(right)?;
                 let op_str = match op {
@@ -450,12 +506,14 @@ impl Codegen {
             } => {
                 let obj = self.emit_expr(object)?;
                 let expr = match prop {
-                    MemberProp::Name(p) => {
-                        if p.parse::<u32>().is_ok() || !p.chars().all(|c| c.is_alphanumeric() || c == '_') {
-                            format!("{}[{:?}]", obj, p.as_ref())
+                    MemberProp::Name { name, .. } => {
+                        if name.parse::<u32>().is_ok()
+                            || !name.chars().all(|c| c.is_alphanumeric() || c == '_')
+                        {
+                            format!("{}[{:?}]", obj, name.as_ref())
                         } else {
                             let sep = if *optional { "?." } else { "." };
-                            format!("{}{}{}", obj, sep, p.as_ref())
+                            format!("{}{}{}", obj, sep, name.as_ref())
                         }
                     }
                     MemberProp::Expr(e) => {
@@ -548,7 +606,9 @@ impl Codegen {
             Expr::PrefixDec { name, .. } => {
                 format!("--{}", Self::escape_ident(name.as_ref()))
             }
-            Expr::CompoundAssign { name, op, value, .. } => {
+            Expr::CompoundAssign {
+                name, op, value, ..
+            } => {
                 let n = Self::escape_ident(name.as_ref());
                 let v = self.emit_expr(value)?;
                 let op_str = match op {
@@ -560,7 +620,9 @@ impl Codegen {
                 };
                 format!("({} {} {})", n, op_str, v)
             }
-            Expr::LogicalAssign { name, op, value, .. } => {
+            Expr::LogicalAssign {
+                name, op, value, ..
+            } => {
                 let n = Self::escape_ident(name.as_ref());
                 let v = self.emit_expr(value)?;
                 let op_str = match op {
@@ -570,7 +632,12 @@ impl Codegen {
                 };
                 format!("({} {} {})", n, op_str, v)
             }
-            Expr::MemberAssign { object, prop, value, .. } => {
+            Expr::MemberAssign {
+                object,
+                prop,
+                value,
+                ..
+            } => {
                 let obj = self.emit_expr(object)?;
                 let val = self.emit_expr(value)?;
                 format!("({}.{} = {})", obj, prop.as_ref(), val)
@@ -652,7 +719,6 @@ impl Codegen {
             CallArg::Spread(e) => Ok(format!("...{}", self.emit_expr(e)?)),
         }
     }
-
 }
 
 /// Compile a single program (no imports) to JavaScript. JSX lowers to `h` / `Fragment` (Lattish).
@@ -663,29 +729,45 @@ pub fn compile_with_jsx(program: &Program, optimize: bool) -> Result<String, Com
         program.clone()
     };
     let mut g = Codegen::new();
-    g.emit_program(&program)?;
+    g.emit_program(&program, None, None)?;
     Ok(g.output)
 }
 
-/// Compile a project from entry path, resolving and merging modules.
-/// Uses shared resolve from tishlang_compile (same pipeline as native/WASM).
-pub fn compile_project_with_jsx(
-    entry_path: &std::path::Path,
-    project_root: Option<&std::path::Path>,
+/// JavaScript plus optional v3 source map JSON (for publishing Tish libraries consumed from JS/TS).
+#[derive(Debug, Clone)]
+pub struct JsBundle {
+    pub js: String,
+    pub source_map_json: Option<String>,
+}
+
+/// Same as [`compile_project_with_jsx`] plus a v3 source map pointing at merged statements’ original `.tish` files.
+/// **Does not run AST optimization** (required so statement ↔ file alignment stays valid).
+pub fn compile_project_with_jsx_and_source_map(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_js_file_name: &str,
+) -> Result<JsBundle, CompileError> {
+    compile_project_js_inner(entry_path, project_root, false, true, output_js_file_name)
+}
+
+fn compile_project_js_inner(
+    entry_path: &Path,
+    project_root: Option<&Path>,
     optimize: bool,
-) -> Result<String, CompileError> {
+    emit_source_map: bool,
+    output_js_file_name: &str,
+) -> Result<JsBundle, CompileError> {
     use tishlang_ast::Statement;
     let modules = tishlang_compile::resolve_project(entry_path, project_root)
         .map_err(|e| CompileError { message: e })?;
     tishlang_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
-    let program = {
-        let prog = tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
-        if optimize {
-            tishlang_opt::optimize(&prog)
-        } else {
-            prog
-        }
+    let merged = tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
+    let program = if optimize {
+        tishlang_opt::optimize(&merged.program)
+    } else {
+        merged.program.clone()
     };
+    let stmt_sources = merged.statement_sources;
     let default_export = program.statements.iter().find_map(|s| {
         if let Statement::VarDecl { name, .. } = s {
             let n = name.as_ref();
@@ -698,9 +780,71 @@ pub fn compile_project_with_jsx(
             None
         }
     });
-    let mut js = compile_with_jsx(&program, optimize)?;
+    if emit_source_map && optimize {
+        return Err(CompileError {
+            message: "internal: source map requested with optimize".into(),
+        });
+    }
+    let root = project_root
+        .map(Path::to_path_buf)
+        .or_else(|| entry_path.parent().map(Path::to_path_buf))
+        .unwrap_or_else(|| PathBuf::from("."));
+    let mut gen = Codegen::new();
+    let mut map_builder = if emit_source_map {
+        let mut b = SourceMapBuilder::new(Some(output_js_file_name));
+        b.set_source_root(Some(""));
+        Some(b)
+    } else {
+        None
+    };
+    if let Some(ref mut b) = map_builder {
+        gen.emit_program(
+            &program,
+            Some((stmt_sources.as_slice(), root.as_path())),
+            Some(b),
+        )?;
+    } else {
+        gen.emit_program(&program, None, None)?;
+    }
+    let mut js = gen.output;
     if let Some(name) = default_export {
         js.push_str(&format!("\nexport default {};\n", name));
     }
-    Ok(js)
+    let map_json = if let Some(b) = map_builder {
+        let sm = b.into_sourcemap();
+        let mut v = Vec::new();
+        sm.to_writer(&mut v).map_err(|e| CompileError {
+            message: e.to_string(),
+        })?;
+        Some(String::from_utf8(v).map_err(|e| CompileError {
+            message: e.to_string(),
+        })?)
+    } else {
+        None
+    };
+    Ok(JsBundle {
+        js,
+        source_map_json: map_json,
+    })
+}
+
+/// Compile a project from entry path, resolving and merging modules.
+/// Uses shared resolve from tishlang_compile (same pipeline as native/WASM).
+pub fn compile_project_with_jsx(
+    entry_path: &std::path::Path,
+    project_root: Option<&std::path::Path>,
+    optimize: bool,
+) -> Result<String, CompileError> {
+    let stem = entry_path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("out.js");
+    let out_name = if stem.ends_with(".tish") {
+        format!("{}.js", stem.trim_end_matches(".tish"))
+    } else {
+        format!("{stem}.js")
+    };
+    Ok(
+        compile_project_js_inner(entry_path, project_root, optimize, false, &out_name)?.js,
+    )
 }