@tishlang/tish 1.0.27 → 1.0.29

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.0.27"
+version = "1.0.29"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/main.rs

@@ -56,9 +56,6 @@ struct CompileArgs {
     features: Vec<String>,
     #[arg(long)]
     no_optimize: bool,
-    /// JS target only: `lattish` (default), `vdom` (vnode + patch; use with Lattish createRoot).
-    #[arg(long = "jsx", value_name = "MODE", default_value = "lattish")]
-    jsx_mode: String,
     #[arg(required = true)]
     file: String,
 }
@@ -94,7 +91,6 @@ fn main() {
             &a.native_backend,
             &a.features,
             a.no_optimize || no_opt_env,
-            &a.jsx_mode,
         ),
         Some(Commands::DumpAst { file }) => dump_ast(&file),
         None => run_repl("vm", false), // No args = REPL
@@ -339,29 +335,7 @@ fn tish_history_path() -> Option<PathBuf> {
     home.map(|h| PathBuf::from(h).join(".tish_history"))
 }
 
-fn parse_jsx_mode(s: &str) -> Result<tishlang_compile_js::JsxMode, String> {
-    match s {
-        "legacy" => Err(
-            "--jsx legacy was removed. Use --jsx lattish (default) with lattish merged into your \
-             bundle, or --jsx vdom with Lattish's createRoot."
-                .to_string(),
-        ),
-        "vdom" => Ok(tishlang_compile_js::JsxMode::Vdom),
-        "lattish" => Ok(tishlang_compile_js::JsxMode::LattishH),
-        other => Err(format!(
-            "Unknown --jsx {:?}: use lattish (default) or vdom.",
-            other
-        )),
-    }
-}
-
-fn compile_to_js(
-    input_path: &Path,
-    output_path: &str,
-    optimize: bool,
-    jsx: &str,
-) -> Result<(), String> {
-    let jsx_mode = parse_jsx_mode(jsx)?;
+fn compile_to_js(input_path: &Path, output_path: &str, optimize: bool) -> Result<(), String> {
     let project_root = input_path.parent().and_then(|p| {
         if p.file_name().and_then(|n| n.to_str()) == Some("src") {
             p.parent()
@@ -382,13 +356,13 @@ fn compile_to_js(
         } else {
             program
         };
-        tishlang_compile_js::compile_with_jsx(&p, optimize, jsx_mode).map_err(|e| format!("{}", e))?
+        tishlang_compile_js::compile_with_jsx(&p, optimize).map_err(|e| format!("{}", e))?
     } else if input_path.extension().map(|e| e == "js") == Some(true) {
         let source = fs::read_to_string(input_path).map_err(|e| format!("{}", e))?;
         let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        tishlang_compile_js::compile_with_jsx(&program, optimize, jsx_mode).map_err(|e| format!("{}", e))?
+        tishlang_compile_js::compile_with_jsx(&program, optimize).map_err(|e| format!("{}", e))?
     } else {
-        tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize, jsx_mode)
+        tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize)
             .map_err(|e| format!("{}", e))?
     };
 
@@ -418,7 +392,6 @@ fn compile_file(
     native_backend: &str,
     cli_features: &[String],
     no_optimize: bool,
-    jsx: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path =
@@ -427,7 +400,7 @@ fn compile_file(
     let is_js = input_path.extension().map(|e| e == "js") == Some(true);
 
     if target == "js" {
-        return compile_to_js(&input_path, output_path, optimize, jsx.trim());
+        return compile_to_js(&input_path, output_path, optimize);
     }
 
     if target == "wasm" && is_js {
@@ -539,7 +512,7 @@ mod cli_tests {
     use super::{Cli, Commands};
 
     #[test]
-    fn compile_jsx_defaults_to_lattish() {
+    fn compile_js_target_parses() {
         let cli = Cli::try_parse_from([
             "tish",
             "compile",
@@ -551,27 +524,7 @@ mod cli_tests {
         ])
         .unwrap();
         match cli.command {
-            Some(Commands::Compile(a)) => assert_eq!(a.jsx_mode.as_str(), "lattish"),
-            _ => panic!("expected Compile"),
-        }
-    }
-
-    #[test]
-    fn compile_jsx_flag_vdom() {
-        let cli = Cli::try_parse_from([
-            "tish",
-            "compile",
-            "a.tish",
-            "--target",
-            "js",
-            "--jsx",
-            "vdom",
-            "-o",
-            "x.js",
-        ])
-        .unwrap();
-        match cli.command {
-            Some(Commands::Compile(a)) => assert_eq!(a.jsx_mode.as_str(), "vdom"),
+            Some(Commands::Compile(a)) => assert_eq!(a.file, "m.tish"),
             _ => panic!("expected Compile"),
         }
     }

package/crates/tish_compile_js/Cargo.toml

@@ -10,7 +10,6 @@ repository = { workspace = true }
 default = []
 
 [dependencies]
-tishlang_jsx_web = { path = "../tish_jsx_web", version = ">=0.1" }
 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

@@ -9,23 +9,11 @@ use tishlang_ast::{
 use crate::error::CompileError;
 use crate::js_intrinsics::{JsIntrinsic, JsIntrinsics};
 
-/// How JSX lowers for `--target js`. Native targets never use this.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub enum JsxMode {
-    /// `h(tag, props, [children])` + `Fragment` (Lattish.tish). Import `h` / `Fragment` from lattish.
-    #[default]
-    LattishH,
-    /// Vnode `__vdom_h` + `window.__lattishVdomPatch` (Lattish createRoot must use patch).
-    Vdom,
-}
-
 struct Codegen {
     output: String,
     indent: usize,
     in_async: bool,
-    uses_jsx: bool,
     intrinsics: JsIntrinsics,
-    jsx_mode: JsxMode,
 }
 
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
@@ -36,14 +24,12 @@ fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
 }
 
 impl Codegen {
-    fn new(jsx_mode: JsxMode) -> Self {
+    fn new() -> Self {
         Self {
             output: String::new(),
             indent: 0,
             in_async: false,
-            uses_jsx: false,
             intrinsics: JsIntrinsics::new(),
-            jsx_mode,
         }
     }
 
@@ -72,25 +58,12 @@ impl Codegen {
 
     fn emit_program(&mut self, program: &Program) -> Result<(), CompileError> {
         self.write("// Generated by tishlang_compile_js\n");
-        // First pass: check if JSX is used (we'll set uses_jsx during emit)
         for stmt in &program.statements {
             self.emit_statement(stmt)?;
         }
         self.output = self
             .intrinsics
             .prepend_runtime_preamble(std::mem::take(&mut self.output));
-        if self.uses_jsx {
-            match self.jsx_mode {
-                JsxMode::Vdom => {
-                    self.output = format!(
-                        "{}\n{}",
-                        tishlang_jsx_web::VDOM_PRELUDE,
-                        self.output
-                    );
-                }
-                JsxMode::LattishH => {}
-            }
-        }
         Ok(())
     }
 
@@ -653,7 +626,6 @@ impl Codegen {
                 format!("(await {})", o)
             }
             Expr::JsxElement { tag, props, children, .. } => {
-                self.uses_jsx = true;
                 let tag_str = if tag.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) {
                     tag.as_ref().to_string()
                 } else {
@@ -663,28 +635,13 @@ impl Codegen {
                 let children_strs: Result<Vec<_>, _> =
                     children.iter().map(|c| self.emit_jsx_child(c)).collect();
                 let children_str = children_strs?.join(", ");
-                match self.jsx_mode {
-                    JsxMode::LattishH => {
-                        format!("h({}, {}, [{}])", tag_str, props_str, children_str)
-                    }
-                    JsxMode::Vdom => {
-                        format!("__vdom_h({}, {}, [{}])", tag_str, props_str, children_str)
-                    }
-                }
+                format!("h({}, {}, [{}])", tag_str, props_str, children_str)
             }
             Expr::JsxFragment { children, .. } => {
-                self.uses_jsx = true;
                 let children_strs: Result<Vec<_>, _> =
                     children.iter().map(|c| self.emit_jsx_child(c)).collect();
                 let children_str = children_strs?.join(", ");
-                match self.jsx_mode {
-                    JsxMode::LattishH => {
-                        format!("h(Fragment, null, [{}])", children_str)
-                    }
-                    JsxMode::Vdom => {
-                        format!("__vdom_h(__Fragment, null, [{}])", children_str)
-                    }
-                }
+                format!("h(Fragment, null, [{}])", children_str)
             }
             Expr::NativeModuleLoad { spec, .. } => {
                 return Err(CompileError {
@@ -754,18 +711,14 @@ impl Codegen {
     }
 }
 
-/// Compile a single program (no imports) to JavaScript.
-pub fn compile_with_jsx(
-    program: &Program,
-    optimize: bool,
-    jsx_mode: JsxMode,
-) -> Result<String, CompileError> {
+/// Compile a single program (no imports) to JavaScript. JSX lowers to `h` / `Fragment` (Lattish).
+pub fn compile_with_jsx(program: &Program, optimize: bool) -> Result<String, CompileError> {
     let program = if optimize {
         tishlang_opt::optimize(program)
     } else {
         program.clone()
     };
-    let mut g = Codegen::new(jsx_mode);
+    let mut g = Codegen::new();
     g.emit_program(&program)?;
     Ok(g.output)
 }
@@ -776,7 +729,6 @@ pub fn compile_project_with_jsx(
     entry_path: &std::path::Path,
     project_root: Option<&std::path::Path>,
     optimize: bool,
-    jsx_mode: JsxMode,
 ) -> Result<String, CompileError> {
     use tishlang_ast::Statement;
     let modules = tishlang_compile::resolve_project(entry_path, project_root)
@@ -802,7 +754,7 @@ pub fn compile_project_with_jsx(
             None
         }
     });
-    let mut js = compile_with_jsx(&program, optimize, jsx_mode)?;
+    let mut js = compile_with_jsx(&program, optimize)?;
     if let Some(name) = default_export {
         js.push_str(&format!("\nexport default {};\n", name));
     }

package/crates/tish_compile_js/src/lib.rs

@@ -8,14 +8,12 @@ mod js_intrinsics;
 #[cfg(test)]
 mod tests_jsx;
 
-pub use codegen::{compile_project_with_jsx, compile_with_jsx, JsxMode};
+pub use codegen::{compile_project_with_jsx, compile_with_jsx};
 pub use error::CompileError;
 
-/// Default JSX mode lowers to Lattish-style calls (implementation detail). Import what you use from
-/// `lattish` (e.g. `useState`, `createRoot`); the merged bundle includes the JSX runtime from that
-/// module. JSX-only files can use `import {} from "lattish"` to pull it in without bindings.
+/// JSX lowers to `h` / `Fragment`; merge the `lattish` runtime for hooks and DOM.
 pub fn compile(program: &tishlang_ast::Program, optimize: bool) -> Result<String, CompileError> {
-    compile_with_jsx(program, optimize, JsxMode::LattishH)
+    compile_with_jsx(program, optimize)
 }
 
 pub fn compile_project(
@@ -23,5 +21,5 @@ pub fn compile_project(
     project_root: Option<&std::path::Path>,
     optimize: bool,
 ) -> Result<String, CompileError> {
-    compile_project_with_jsx(entry_path, project_root, optimize, JsxMode::LattishH)
+    compile_project_with_jsx(entry_path, project_root, optimize)
 }

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -4,13 +4,13 @@ mod tests {
 
     use tishlang_parser::parse;
 
-    use crate::{compile_project_with_jsx, compile_with_jsx, JsxMode};
+    use crate::{compile_project_with_jsx, compile_with_jsx};
 
     #[test]
     fn lattish_jsx_emits_h_with_children_array() {
         let src = r#"fn X() { return <div class="a">{"hi"}</div> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"), "{}", js);
         assert!(!js.contains("function __h("));
     }
@@ -19,7 +19,7 @@ mod tests {
     fn fragment_lattish_uses_fragment_symbol() {
         let src = "fn X() { return <><b>{\"1\"}</b></> }";
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(js.contains("h(Fragment, null, ["));
     }
 
@@ -27,7 +27,7 @@ mod tests {
     fn jsx_text_whitespace_coalesced() {
         let src = r#"fn X() { return <p>First paragraph</p> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             js.contains("\"First paragraph\""),
             "expected \"First paragraph\" in output, got: {}",
@@ -43,7 +43,7 @@ mod tests {
     fn jsx_text_whitespace_coalesced_multiline() {
         let src = "fn App() {\n  return <p>First paragraph</p>\n}";
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             js.contains("\"First paragraph\""),
             "multiline: expected \"First paragraph\", got: {}",
@@ -56,7 +56,7 @@ mod tests {
         // Punctuation (e.g. !) concatenates without space: "work!" not "work !"
         let src = r#"fn X() { return <p>work!</p> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(js.contains(r#""work!""#), "expected 'work!', got: {}", &js[..400.min(js.len())]);
     }
 
@@ -64,7 +64,7 @@ mod tests {
     fn jsx_text_emojis() {
         let src = r#"fn X() { return <p>hello 😔</p> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(js.contains("😔"), "expected emoji, got: {}", &js[..400.min(js.len())]);
     }
 
@@ -78,7 +78,7 @@ mod tests {
         f.write_all(src.as_bytes()).unwrap();
         f.sync_all().unwrap();
         drop(f);
-        let js = compile_project_with_jsx(&path, Some(&dir), false, JsxMode::LattishH)
+        let js = compile_project_with_jsx(&path, Some(&dir), false)
             .expect("compile_project_with_jsx failed");
         assert!(
             js.contains("\"First paragraph\""),
@@ -89,12 +89,14 @@ mod tests {
     }
 
     #[test]
-    fn vdom_emits_vdom_h() {
-        let src = r#"fn X() { return <p/> }"#;
+    fn jsx_never_emits_vdom_helpers_or_prelude_flags() {
+        let src = r#"fn X() { return <div class="x">{"a"}</div> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::Vdom).unwrap();
-        assert!(js.contains("__vdom_h(\"p\", null, [])"), "{}", &js[..600.min(js.len())]);
-        assert!(js.contains("__lattishVdomPatch"));
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(js.contains("h(\"div\", { class: \"x\" }"), "{}", &js[..500.min(js.len())]);
+        assert!(!js.contains("__vdom_h"), "{}", &js[..600.min(js.len())]);
+        assert!(!js.contains("window.__LATTISH_JSX_VDOM"), "{}", &js[..600.min(js.len())]);
+        assert!(!js.contains("__lattishVdomPatch"), "{}", &js[..600.min(js.len())]);
     }
 
     /// Component calls like {Panel()} return DOM elements. Wrapping in String() produces [object HTMLDivElement].
@@ -105,7 +107,7 @@ fn Panel() { return <div class="p">content</div> }
 fn App() { return <div>{Panel()}</div> }
 "#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             js.contains("Panel()"),
             "component call should appear as Panel(), got: {}",
@@ -123,7 +125,7 @@ fn App() { return <div>{Panel()}</div> }
     fn jsx_nested_element_not_wrapped_in_string() {
         let src = r#"fn X() { return <div><span>inner</span></div> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             !js.contains("String(h("),
             "nested JSX elements must NOT be wrapped in String(). got: {}",
@@ -136,7 +138,7 @@ fn App() { return <div>{Panel()}</div> }
     fn jsx_literal_number_wrapped_in_string() {
         let src = r#"fn X() { return <span>{42}</span> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             js.contains("String(42)"),
             "literal number in JSX should be wrapped in String(). got: {}",
@@ -156,11 +158,57 @@ fn FileList() {
 }
 "#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             !js.contains("String(items)"),
             "array/ident in JSX must NOT be wrapped in String() - causes [object HTMLButtonElement]. got: {}",
             &js[..600.min(js.len())]
         );
     }
+
+    /// `>` inside `{ ... }` attribute values must be a comparison operator, not end of opening tag.
+    #[test]
+    fn jsx_gt_comparison_inside_attribute_expression() {
+        let src = r#"fn X() {
+  return <button
+    type="button"
+    onclick={() => {
+      let nm = "a"
+      if (nm && nm.length > 0) { print(nm) }
+    }}
+  >{"ok"}</button>
+}"#;
+        let program = parse(src).expect("parse multi-line JSX with > comparison in attr");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("length > 0") || js.contains("length>0"),
+            "expected compiled JS to preserve greater-than comparison, got: {}",
+            &js[..800.min(js.len())]
+        );
+    }
+
+    /// Nested JSX inside an attribute callback must still close inner `<tag>` correctly.
+    #[test]
+    fn jsx_nested_element_inside_attribute_expression() {
+        let src = r#"fn X() {
+  return <button
+    onclick={() => {
+      let x = <span>{"inner"}</span>
+      print(x)
+    }}
+  >{"outer"}</button>
+}"#;
+        let program = parse(src).expect("parse nested JSX inside onclick");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("\"inner\""),
+            "expected nested span text in output, got: {}",
+            &js[..900.min(js.len())]
+        );
+        assert!(
+            js.contains("\"outer\""),
+            "expected button child text in output, got: {}",
+            &js[..900.min(js.len())]
+        );
+    }
 }

package/crates/tish_compiler_wasm/src/lib.rs

@@ -10,7 +10,6 @@ mod resolve_virtual;
 use base64::Engine;
 use resolve_virtual::{detect_cycles_virtual, merge_modules_virtual, resolve_virtual};
 use std::collections::HashMap;
-use tishlang_compile_js::JsxMode;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
@@ -24,7 +23,7 @@ pub fn compile_to_bytecode(source: &str) -> Result<String, JsValue> {
 #[wasm_bindgen]
 pub fn compile_to_js(source: &str) -> Result<String, JsValue> {
     let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    tishlang_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
+    tishlang_compile_js::compile_with_jsx(&program, true)
         .map_err(|e| JsValue::from_str(&e.message))
 }
 
@@ -50,6 +49,6 @@ pub fn compile_to_js_with_imports(entry_path: &str, files_json: &str) -> Result<
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
     let program = tishlang_opt::optimize(&program);
-    tishlang_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
+    tishlang_compile_js::compile_with_jsx(&program, true)
         .map_err(|e| JsValue::from_str(&e.message))
 }

package/crates/tish_jsx_web/Cargo.toml

@@ -2,7 +2,7 @@
 name = "tishlang_jsx_web"
 version = "0.1.0"
 edition = "2021"
-description = "JSX / DOM runtime snippets for Tish JS target only (not used by native)"
+description = "Workspace placeholder; Lattish runtime is the lattish npm/git repo (not vendored here)"
 
 license-file = { workspace = true }
 repository = { workspace = true }

package/crates/tish_jsx_web/README.md

@@ -1,18 +1,5 @@
-# tish_jsx_web
+# tishlang_jsx_web
 
-Web-only crate for the Tish JS backend:
+Workspace placeholder. **Lattish** (`h`, `Fragment`, hooks, reconciler) lives in the [lattish](https://github.com/tishlang/lattish) repository — edit **`lattish/src/Lattish.tish` only**.
 
-- **`VDOM_PRELUDE`** — vnode helpers + `window.__lattishVdomPatch` + `window.__LATTISH_JSX_VDOM` for `--jsx vdom`.
-
-Native / non-JS compiler targets must not depend on this crate; only `tish_compile_js` pulls it in.
-
-## Vendor runtime
-
-`vendor/Lattish.tish` is a copy refreshed from the **lattish** npm package. Run `just refresh-lattish` to update from the sibling lattish package.
-
-## JSX modes (`--jsx`)
-
-| Mode | JSX lowers to | Preamble |
-|------|----------------|----------|
-| `lattish` (default) | Lattish-style JSX lowering | none — merge `Lattish.tish` by importing any export you need (or `import {} from "lattish"` for JSX-only) |
-| `vdom` | `__vdom_h(...)` | VDOM prelude; Lattish `createRoot` patches the tree when `window.__LATTISH_JSX_VDOM` is set |
+Tish lowers JSX to `h` / `Fragment` via `tishlang_compile_js`; apps merge a compiled `Lattish.js` from npm or a path dependency.

package/crates/tish_jsx_web/src/lib.rs

@@ -1,157 +1,2 @@
-//! Web-only JSX helpers for `tish compile --target js`.
-//! Native and WASM native paths must not depend on this crate.
-
-/// VDOM: vnode `__vdom_h` + `window.__lattishVdomPatch` for Lattish batched flush.
-pub const VDOM_PRELUDE: &str = r#"window.__LATTISH_JSX_VDOM = true;
-const __Fragment = Symbol('Fragment');
-function __vdom_h(tag, props, children) {
-  if (children === undefined || children === null) children = [];
-  if (!Array.isArray(children)) children = [children];
-  return { tag: tag, props: props || null, children: children, _el: null };
-}
-function __vdom_flatten(ch) {
-  const out = [];
-  function w(c) {
-    if (c == null) return;
-    if (Array.isArray(c)) { for (let i = 0; i < c.length; i++) w(c[i]); return; }
-    if (typeof c === 'object' && c && c.tag === __Fragment) {
-      const inner = c.children;
-      if (Array.isArray(inner)) for (let i = 0; i < inner.length; i++) w(inner[i]);
-      return;
-    }
-    out.push(c);
-  }
-  if (Array.isArray(ch)) for (let i = 0; i < ch.length; i++) w(ch[i]);
-  return out;
-}
-function __vdom_mount(v) {
-  if (typeof v === 'string') return document.createTextNode(v);
-  if (v.tag === __Fragment) {
-    const f = document.createDocumentFragment();
-    const ch = __vdom_flatten(v.children);
-    for (let i = 0; i < ch.length; i++) f.appendChild(__vdom_mount(ch[i]));
-    return f;
-  }
-  const el = document.createElement(v.tag);
-  const p = v.props || {};
-  for (const k of Object.keys(p)) {
-    const val = p[k];
-    if (val === true) el.setAttribute(k, k);
-    else if (val !== false && val != null) {
-      if (k === 'class' || k === 'className') el.className = val;
-      else if (k.startsWith('on') && typeof val === 'function') el[k.toLowerCase()] = val;
-      else if (k === 'value' && (v.tag === 'input' || v.tag === 'textarea' || v.tag === 'select')) el.value = val;
-      else el.setAttribute(k, String(val));
-    }
-  }
-  const ch = __vdom_flatten(v.children);
-  for (let i = 0; i < ch.length; i++) el.appendChild(__vdom_mount(ch[i]));
-  v._el = el;
-  return el;
-}
-function __vdomPatchEl(el, ov, nv) {
-  if (!el || !ov || !nv) return false;
-  if (typeof nv === 'string') {
-    if (el.nodeType === 3) el.textContent = nv;
-    return true;
-  }
-  if (ov.tag !== nv.tag) return false;
-  nv._el = el;
-  const p = nv.props || {};
-  const op = ov.props || {};
-  for (const k of Object.keys(p)) {
-    if (p[k] !== op[k]) {
-      const val = p[k];
-      if (k === 'class' || k === 'className') el.className = val || '';
-      else if (k.startsWith('on')) el[k.toLowerCase()] = val || null;
-      else if (k === 'value' && (nv.tag === 'input' || nv.tag === 'textarea' || nv.tag === 'select')) {
-        if (el !== document.activeElement) el.value = val;
-      } else el.setAttribute(k, String(val));
-    }
-  }
-  const ocx = __vdom_flatten(ov.children);
-  const ncx = __vdom_flatten(nv.children);
-  let fullCh = ocx.length !== ncx.length;
-  if (!fullCh) {
-    for (let j = 0; j < ncx.length; j++) {
-      const o = ocx[j], n = ncx[j];
-      if (typeof n === 'string') { if (typeof o !== 'string') fullCh = true; }
-      else if (typeof o === 'string') fullCh = true;
-      else if (!o || o.tag !== n.tag) fullCh = true;
-      if (fullCh) break;
-    }
-  }
-  if (fullCh) {
-    const nodes = [];
-    for (let j = 0; j < ncx.length; j++) nodes.push(__vdom_mount(ncx[j]));
-    el.replaceChildren(...nodes);
-    return true;
-  }
-  let i = 0;
-  while (i < ncx.length) {
-    const o = ocx[i], n = ncx[i];
-    const childEl = el.childNodes[i];
-    if (n == null) {
-      if (childEl) el.removeChild(childEl);
-      i++;
-      continue;
-    }
-    if (o == null) {
-      el.appendChild(__vdom_mount(n));
-      i++;
-      continue;
-    }
-    if (typeof n === 'string') {
-      if (childEl && childEl.nodeType === 3) childEl.textContent = n;
-      else {
-        const m = __vdom_mount(n);
-        if (childEl) el.replaceChild(m, childEl);
-        else el.appendChild(m);
-      }
-      i++;
-      continue;
-    }
-    if (typeof o === 'string' || o.tag !== n.tag) {
-      const m = __vdom_mount(n);
-      if (childEl) el.replaceChild(m, childEl);
-      else el.appendChild(m);
-      i++;
-      continue;
-    }
-    if (!childEl || !__vdomPatchEl(childEl, o, n)) {
-      const m = __vdom_mount(n);
-      if (childEl) el.replaceChild(m, childEl);
-      else el.appendChild(m);
-    }
-    i++;
-  }
-  return true;
-}
-window.__lattishVdomPatch = function(container, oldTree, newTree) {
-  try {
-    if (oldTree == null) {
-      container.replaceChildren(__vdom_mount(newTree));
-      return;
-    }
-    const el = container.firstChild;
-    if (!el) {
-      container.appendChild(__vdom_mount(newTree));
-      return;
-    }
-    if (typeof newTree === 'string' || oldTree.tag !== newTree.tag) {
-      container.replaceChildren(__vdom_mount(newTree));
-      return;
-    }
-    if (!__vdomPatchEl(el, oldTree, newTree)) {
-      container.replaceChildren(__vdom_mount(newTree));
-    }
-  } catch (err) {
-    console.warn('Lattish VDOM patch failed, full remount', err);
-    try {
-      container.replaceChildren(__vdom_mount(newTree));
-    } catch (e2) {
-      console.error('Lattish VDOM remount failed', e2);
-    }
-  }
-};
-"#;
+//! Placeholder crate kept for workspace / crates.io ordering. The JSX runtime is maintained in the
+//! [lattish](https://github.com/tishlang/lattish) repo (`src/Lattish.tish` only — do not vendor a copy here).

package/crates/tish_lexer/src/lib.rs

@@ -14,6 +14,16 @@ use std::str::Chars;
 const INDENT_WIDTH: usize = 2;
 const TAB_AS_LEVELS: usize = 1;
 
+/// One JSX element on the stack: tracks whether we are still in its opening tag (`<Tag ...`)
+/// and how many `{` are open inside that element's **attribute values** (embedded JS).
+/// This lets `>` be a comparison operator inside `{...}` while still closing `<span>` when
+/// `attr_value_braces == 0` for the innermost element (React-like).
+#[derive(Debug, Clone)]
+struct JsxEl {
+    in_opener: bool,
+    attr_value_braces: i32,
+}
+
 #[derive(Debug, Clone)]
 pub struct Lexer<'a> {
     chars: Peekable<Chars<'a>>,
@@ -27,7 +37,7 @@ pub struct Lexer<'a> {
     jsx_after_gt: bool,
     jsx_in_opening_tag: bool,
     jsx_saw_slash_before_gt: bool,
-    jsx_brace_depth: i32,
+    jsx_stack: Vec<JsxEl>,
     jsx_depth: i32,
     jsx_child_brace_depth: i32,
     jsx_in_closing_tag: bool,
@@ -47,13 +57,18 @@ impl<'a> Lexer<'a> {
             jsx_after_gt: false,
             jsx_in_opening_tag: false,
             jsx_saw_slash_before_gt: false,
-            jsx_brace_depth: 0,
+            jsx_stack: Vec::new(),
             jsx_depth: 0,
             jsx_child_brace_depth: 0,
             jsx_in_closing_tag: false,
         }
     }
 
+    #[inline]
+    fn jsx_sync_in_opening_tag(&mut self) {
+        self.jsx_in_opening_tag = self.jsx_stack.last().map(|e| e.in_opener).unwrap_or(false);
+    }
+
     fn read_jsx_text(&mut self, start: (usize, usize)) -> Result<Option<Token>, String> {
         let mut s = String::new();
         loop {
@@ -305,18 +320,33 @@ impl<'a> Lexer<'a> {
             '(' => TokenKind::LParen,
             ')' => TokenKind::RParen,
             '{' => {
-                if self.jsx_in_opening_tag { self.jsx_brace_depth += 1; }
-                else if self.jsx_depth > 0 { self.jsx_child_brace_depth += 1; }
+                if self.jsx_in_opening_tag {
+                    if let Some(top) = self.jsx_stack.last_mut() {
+                        top.attr_value_braces += 1;
+                    }
+                } else if self.jsx_depth > 0 {
+                    self.jsx_child_brace_depth += 1;
+                }
                 if let Some(depth) = self.template_brace_stack.last_mut() {
                     *depth += 1;
                 }
                 TokenKind::LBrace
             }
             '}' => {
-                if self.jsx_brace_depth > 0 { self.jsx_brace_depth -= 1; }
-                else if self.jsx_child_brace_depth > 0 {
+                let mut handled = false;
+                if let Some(top) = self.jsx_stack.last() {
+                    if top.in_opener && top.attr_value_braces > 0 {
+                        if let Some(top) = self.jsx_stack.last_mut() {
+                            top.attr_value_braces -= 1;
+                        }
+                        handled = true;
+                    }
+                }
+                if !handled && self.jsx_child_brace_depth > 0 {
                     self.jsx_child_brace_depth -= 1;
-                    if self.jsx_child_brace_depth == 0 { self.jsx_after_gt = true; }
+                    if self.jsx_child_brace_depth == 0 {
+                        self.jsx_after_gt = true;
+                    }
                 }
                 if let Some(depth) = self.template_brace_stack.last_mut() {
                     *depth -= 1;
@@ -358,6 +388,10 @@ impl<'a> Lexer<'a> {
                 else if self.peek() == Some('/') { self.jsx_in_closing_tag = true; TokenKind::Lt }
                 else if self.peek() == Some('>') || self.peek().map(|c| c.is_ascii_alphabetic() || c == '_').unwrap_or(false) {
                     self.jsx_depth += 1;
+                    self.jsx_stack.push(JsxEl {
+                        in_opener: true,
+                        attr_value_braces: 0,
+                    });
                     self.jsx_in_opening_tag = true;
                     TokenKind::Lt
                 } else { TokenKind::Lt }
@@ -366,13 +400,23 @@ impl<'a> Lexer<'a> {
                 if self.peek() == Some('=') { self.advance(); TokenKind::Ge }
                 else if self.peek() == Some('>') { self.advance(); TokenKind::Shr }
                 else {
-                    if self.jsx_in_opening_tag && self.jsx_brace_depth == 0 && !self.jsx_saw_slash_before_gt {
-                        self.jsx_after_gt = true;
-                    }
-                    if self.jsx_in_closing_tag || (self.jsx_in_opening_tag && self.jsx_saw_slash_before_gt) {
+                    if self.jsx_in_closing_tag {
+                        self.jsx_depth = (self.jsx_depth - 1).max(0);
+                        self.jsx_stack.pop();
+                        self.jsx_sync_in_opening_tag();
+                    } else if self.jsx_in_opening_tag && self.jsx_saw_slash_before_gt {
                         self.jsx_depth = (self.jsx_depth - 1).max(0);
+                        self.jsx_stack.pop();
+                        self.jsx_sync_in_opening_tag();
+                    } else if let Some(top) = self.jsx_stack.last_mut() {
+                        if top.in_opener && top.attr_value_braces > 0 {
+                            // `>` is a comparison (or shift) token inside `{ ... }`, not end of opening tag.
+                        } else if top.in_opener && !self.jsx_saw_slash_before_gt {
+                            top.in_opener = false;
+                            self.jsx_after_gt = true;
+                            self.jsx_sync_in_opening_tag();
+                        }
                     }
-                    self.jsx_in_opening_tag = false;
                     self.jsx_in_closing_tag = false;
                     self.jsx_saw_slash_before_gt = false;
                     TokenKind::Gt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, compile to native.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

package/crates/tish_jsx_web/vendor/Lattish.tish

@@ -1,362 +0,0 @@
-// Lattish: Lattish runtime for compiled JSX. Publish to npm; consumed by tish and tish-playground.
-// With `tish compile --target js --jsx vdom`, the compiler injects a prelude that sets
-// window.__LATTISH_JSX_VDOM and __lattishVdomPatch; createRoot then reconciles vnodes.
-
-export let Fragment = Symbol("Lattish.Fragment")
-
-fn __lattishAppend(parent, c) {
-  if (c === null || c === undefined) {
-    return
-  }
-  if (Array.isArray(c)) {
-    let i = 0
-    while (i < c.length) {
-      __lattishAppend(parent, c[i])
-      i = i + 1
-    }
-    return
-  }
-  if (typeof c === "string") {
-    parent.appendChild(document.createTextNode(c))
-  } else {
-    parent.appendChild(c)
-  }
-}
-
-export fn h(tag, props, children) {
-  if (children === undefined || children === null) {
-    children = []
-  }
-  if (typeof tag === "function") {
-    let p = props && props !== null ? props : {}
-    if (children.length > 0) {
-      let newProps = {}
-      let keys = Object.keys(p)
-      let i = 0
-      while (i < keys.length) {
-        newProps[keys[i]] = p[keys[i]]
-        i = i + 1
-      }
-      newProps.children = children
-      p = newProps
-    }
-    return tag(p)
-  }
-  if (tag === Fragment) {
-    let f = document.createDocumentFragment()
-    let i = 0
-    while (i < children.length) {
-      __lattishAppend(f, children[i])
-      i = i + 1
-    }
-    return f
-  }
-  let el = document.createElement(tag)
-  let refVal = null
-  if (props && props !== null) {
-    let keys = Object.keys(props)
-    let ki = 0
-    while (ki < keys.length) {
-      let k = keys[ki]
-      let v = props[k]
-      if (k === "ref") {
-        refVal = v
-      } else {
-        if (k === "disabled") {
-          el.disabled = !!v
-        } else {
-        if (v === true) {
-          el.setAttribute(k, k)
-        } else {
-          if (v !== false && v !== null && v !== undefined) {
-            if (k === "class" || k === "className") {
-              el.className = v
-            } else {
-              if (k.length >= 3 && k[0] === "o" && k[1] === "n" && typeof v === "function") {
-                let eventType = k.slice(2).toLowerCase()
-                el.addEventListener(eventType, v)
-              } else {
-                if (k === "value" && (tag === "input" || tag === "textarea")) {
-                  el.value = v
-                } else {
-                  if (k !== "ref") {
-                    el.setAttribute(k, String(v))
-                  }
-                }
-              }
-            }
-          }
-        }
-        }
-      }
-      ki = ki + 1
-    }
-  }
-  let ci = 0
-  while (ci < children.length) {
-    __lattishAppend(el, children[ci])
-    ci = ci + 1
-  }
-  if (refVal !== null && refVal !== undefined && typeof refVal === "object") {
-    refVal.current = el
-  }
-  return el
-}
-
-export fn text(s) {
-  return s
-}
-
-let __state = []
-let __cursor = 0
-let __container = null
-let __App = null
-let __rootVnode = null
-
-let __memoSlots = []
-let __refSlots = []
-let __layoutEffectSlots = []
-let __effectSlots = []
-
-let __flushScheduled = false
-let __batchDepth = 0
-let __dirtyFromBatch = false
-let __effectsMicrotaskScheduled = false
-
-fn __depsChanged(prev, next) {
-  if (prev === null) {
-    return true
-  }
-  if (next === null || prev === null) {
-    return true
-  }
-  if (prev.length !== next.length) {
-    return true
-  }
-  let j = 0
-  while (j < next.length) {
-    if (prev[j] !== next[j]) {
-      return true
-    }
-    j = j + 1
-  }
-  return false
-}
-
-fn __runLayoutEffects() {
-  let i = 0
-  while (i < __layoutEffectSlots.length) {
-    let s = __layoutEffectSlots[i]
-    if (s && s.pending) {
-      s.pending = false
-      if (s.cleanup) {
-        s.cleanup()
-        s.cleanup = null
-      }
-      let c = s.effect()
-      if (typeof c === "function") {
-        s.cleanup = c
-      }
-    }
-    i = i + 1
-  }
-}
-
-fn __scheduleEffectsFlush() {
-  if (__effectsMicrotaskScheduled) {
-    return
-  }
-  __effectsMicrotaskScheduled = true
-  queueMicrotask(() => {
-    __effectsMicrotaskScheduled = false
-    let i = 0
-    while (i < __effectSlots.length) {
-      let s = __effectSlots[i]
-      if (s && s.pending) {
-        s.pending = false
-        if (s.cleanup) {
-          s.cleanup()
-          s.cleanup = null
-        }
-        let c = s.effect()
-        if (typeof c === "function") {
-          s.cleanup = c
-        }
-      }
-      i = i + 1
-    }
-  })
-}
-
-/// Runs synchronously after DOM is updated (before paint in typical browsers).
-export fn useLayoutEffect(effect, deps) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  while (i >= __layoutEffectSlots.length) {
-    __layoutEffectSlots.push(null)
-  }
-  let slot = __layoutEffectSlots[i]
-  if (slot === null) {
-    slot = { deps: null, effect: null, cleanup: null, pending: false }
-    __layoutEffectSlots[i] = slot
-  }
-  if (__depsChanged(slot.deps, deps)) {
-    slot.deps = deps
-    slot.effect = effect
-    slot.pending = true
-  }
-}
-
-/// Runs after paint (microtask after flush).
-export fn useEffect(effect, deps) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  while (i >= __effectSlots.length) {
-    __effectSlots.push(null)
-  }
-  let slot = __effectSlots[i]
-  if (slot === null) {
-    slot = { deps: null, effect: null, cleanup: null, pending: false }
-    __effectSlots[i] = slot
-  }
-  if (__depsChanged(slot.deps, deps)) {
-    slot.deps = deps
-    slot.effect = effect
-    slot.pending = true
-    __scheduleEffectsFlush()
-  }
-}
-
-fn __usingVdom() {
-  return typeof window !== "undefined" && window.__LATTISH_JSX_VDOM && window.__lattishVdomPatch
-}
-
-fn __flushRender() {
-  __cursor = 0
-  if (__container && __App) {
-    if (__usingVdom()) {
-      let newTree = __App()
-      window.__lattishVdomPatch(__container, __rootVnode, newTree)
-      __rootVnode = newTree
-    } else {
-      let el = __App()
-      __container.replaceChildren(el)
-      __rootVnode = null
-    }
-    __runLayoutEffects()
-    __scheduleEffectsFlush()
-  }
-}
-
-fn __scheduleFlush() {
-  if (__batchDepth > 0) {
-    __dirtyFromBatch = true
-    return
-  }
-  if (__flushScheduled) {
-    return
-  }
-  __flushScheduled = true
-  queueMicrotask(() => {
-    __flushScheduled = false
-    __flushRender()
-  })
-}
-
-export fn unstable_batchedUpdates(run) {
-  __batchDepth = __batchDepth + 1
-  run()
-  __batchDepth = __batchDepth - 1
-  if (__batchDepth === 0 && __dirtyFromBatch) {
-    __dirtyFromBatch = false
-    __flushScheduled = false
-    __flushRender()
-  }
-}
-
-export fn useState(init) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  if (i >= __state.length) {
-    __state.push(init)
-  }
-  fn setState(v) {
-    if (typeof v === "function") {
-      __state[i] = v(__state[i])
-    } else {
-      __state[i] = v
-    }
-    __scheduleFlush()
-  }
-  return [__state[i], setState]
-}
-
-export fn useMemo(deps, factory) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  while (i >= __memoSlots.length) {
-    __memoSlots.push(null)
-  }
-  let slot = __memoSlots[i]
-  let stale = true
-  if (slot) {
-    stale = false
-    if (slot.deps.length !== deps.length) {
-      stale = true
-    } else {
-      let j = 0
-      while (j < deps.length) {
-        if (slot.deps[j] !== deps[j]) {
-          stale = true
-          break
-        }
-        j = j + 1
-      }
-    }
-  }
-  if (stale) {
-    __memoSlots[i] = { deps: deps, value: factory() }
-  }
-  return __memoSlots[i].value
-}
-
-export fn useRef(initial) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  while (i >= __refSlots.length) {
-    __refSlots.push(null)
-  }
-  if (__refSlots[i] === null) {
-    __refSlots[i] = { current: initial }
-  }
-  return __refSlots[i]
-}
-
-export fn createRoot(container) {
-  fn render(App) {
-    __container = container
-    __App = App
-    __state = []
-    __memoSlots = []
-    __refSlots = []
-    __layoutEffectSlots = []
-    __effectSlots = []
-    __cursor = 0
-    __flushScheduled = false
-    __batchDepth = 0
-    __dirtyFromBatch = false
-    __effectsMicrotaskScheduled = false
-    __rootVnode = null
-    if (__usingVdom()) {
-      __rootVnode = App()
-      window.__lattishVdomPatch(container, null, __rootVnode)
-    } else {
-      let el = App()
-      container.replaceChildren(el)
-    }
-    __cursor = 0
-    __runLayoutEffects()
-    __scheduleEffectsFlush()
-  }
-  return { render: render }
-}