@tishlang/tish 2.10.1 → 2.16.13

package/crates/tish_compile_js/src/codegen.rs

@@ -11,6 +11,10 @@ use tishlang_ast::{
 
 use crate::error::CompileError;
 
+/// Default module specifier the JSX runtime (`h` / `Fragment`) is auto-imported from (issue #291).
+/// Matches the repo convention (`import { h } from "lattish"`); overridable via `--jsx-import-source`.
+pub const DEFAULT_JSX_IMPORT_SOURCE: &str = "lattish";
+
 /// JS output mode. `Bundle` flattens every module into one file (imports/exports are resolved away
 /// by `merge_modules`). `Esm` emits one file per module with real ES `import`/`export` statements so
 /// a bundler (Vite/Rollup) can tree-shake and code-split. See issue #177's sibling, #282.
@@ -42,6 +46,9 @@ struct Codegen {
     module_path: PathBuf,
     /// ESM only: the project root, so import targets can be located relative to the output tree.
     project_root: PathBuf,
+    /// ESM only: the module specifier the JSX runtime (`h` / `Fragment`) is auto-imported from when a
+    /// module uses JSX but doesn't import them itself (issue #291). Defaults to `lattish`.
+    jsx_import_source: String,
 }
 
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
@@ -63,10 +70,16 @@ impl Codegen {
             import_rewrite: ImportRewrite::Disk,
             module_path: PathBuf::new(),
             project_root: PathBuf::new(),
+            jsx_import_source: DEFAULT_JSX_IMPORT_SOURCE.to_string(),
         }
     }
 
-    fn new_esm(module_path: PathBuf, project_root: PathBuf, import_rewrite: ImportRewrite) -> Self {
+    fn new_esm(
+        module_path: PathBuf,
+        project_root: PathBuf,
+        import_rewrite: ImportRewrite,
+        jsx_import_source: String,
+    ) -> Self {
         Self {
             output: String::new(),
             indent: 0,
@@ -75,6 +88,7 @@ impl Codegen {
             import_rewrite,
             module_path,
             project_root,
+            jsx_import_source,
         }
     }
 
@@ -139,6 +153,7 @@ impl Codegen {
         map_builder: Option<&mut SourceMapBuilder>,
     ) -> Result<(), CompileError> {
         self.write("// Generated by tishlang_compile_js\n");
+        self.emit_jsx_runtime_auto_import(program)?;
         match (map_sources, map_builder) {
             (Some((srcs, root)), Some(sm)) => {
                 for (i, stmt) in program.statements.iter().enumerate() {
@@ -176,6 +191,34 @@ impl Codegen {
         Ok(())
     }
 
+    /// Auto-import the JSX runtime (`h` / `Fragment`) for ESM modules that use JSX but don't bring
+    /// those bindings into scope themselves (issue #291). In `--format bundle` the merged scope makes
+    /// a single `lattish` import visible everywhere, but each ES module is its own scope, so a JSX
+    /// module that didn't `import { h }` throws `ReferenceError` at load. We inject only the missing
+    /// names (so an explicit `import { h }` isn't duplicated) from `jsx_import_source`, rewritten the
+    /// same way as user imports (disk `.js` path vs. Vite-dev bare specifier). No-op outside ESM.
+    fn emit_jsx_runtime_auto_import(&mut self, program: &Program) -> Result<(), CompileError> {
+        if self.emit_mode != EmitMode::Esm {
+            return Ok(());
+        }
+        let needed = tishlang_ui::jsx::jsx_runtime_imports_needed(program);
+        if needed.is_empty() {
+            return Ok(());
+        }
+        let spec = rewrite_import_to_js(
+            &self.jsx_import_source,
+            &self.module_path,
+            &self.project_root,
+            self.import_rewrite,
+        )?;
+        self.writeln(&format!(
+            "import {{ {} }} from \"{}\";",
+            needed.join(", "),
+            spec
+        ));
+        Ok(())
+    }
+
     fn emit_statement(&mut self, stmt: &Statement) -> Result<(), CompileError> {
         match stmt {
             Statement::Block { statements, .. } => {
@@ -993,6 +1036,39 @@ impl Codegen {
                 let v = self.emit_expr(e)?;
                 self.writeln(&format!("export default {};", v));
             }
+            // #305: re-export in ESM mode — emit the native `export { … } from` / `export * from`,
+            // rewriting the `.tish` specifier to the emitted `.js` module path.
+            ExportDeclaration::ReExport {
+                specifiers,
+                all,
+                from,
+                ..
+            } => {
+                let spec = rewrite_import_to_js(
+                    from.as_ref(),
+                    &self.module_path,
+                    &self.project_root,
+                    self.import_rewrite,
+                )?;
+                if *all {
+                    self.writeln(&format!("export * from {:?};", spec));
+                } else {
+                    let mut parts: Vec<String> = Vec::new();
+                    for s in specifiers {
+                        if let ImportSpecifier::Named { name, alias, .. } = s {
+                            match alias {
+                                Some(a) => parts.push(format!(
+                                    "{} as {}",
+                                    Self::escape_ident(name.as_ref()),
+                                    Self::escape_ident(a.as_ref())
+                                )),
+                                None => parts.push(Self::escape_ident(name.as_ref()).to_string()),
+                            }
+                        }
+                    }
+                    self.writeln(&format!("export {{ {} }} from {:?};", parts.join(", "), spec));
+                }
+            }
         }
         Ok(())
     }
@@ -1235,6 +1311,7 @@ pub fn compile_project_esm(
     entry_path: &Path,
     project_root: Option<&Path>,
     optimize: bool,
+    jsx_import_source: &str,
 ) -> Result<Vec<EmittedJsModule>, CompileError> {
     let modules = tishlang_compile::resolve_project(entry_path, project_root)
         .map_err(|e| CompileError { message: e })?;
@@ -1274,8 +1351,12 @@ pub fn compile_project_esm(
         } else {
             module.program.clone()
         };
-        let mut gen =
-            Codegen::new_esm(mod_canon.clone(), res_root_canon.clone(), ImportRewrite::Disk);
+        let mut gen = Codegen::new_esm(
+            mod_canon.clone(),
+            res_root_canon.clone(),
+            ImportRewrite::Disk,
+            jsx_import_source.to_string(),
+        );
         gen.emit_program(&program, None, None)?;
         out.push(EmittedJsModule {
             relative_path: rel_js,
@@ -1297,6 +1378,7 @@ pub fn compile_module_esm(
     optimize: bool,
     import_rewrite: ImportRewrite,
     source_map: bool,
+    jsx_import_source: &str,
 ) -> Result<JsBundle, CompileError> {
     if source_map && optimize {
         return Err(CompileError {
@@ -1324,7 +1406,12 @@ pub fn compile_module_esm(
         .unwrap_or_else(|| PathBuf::from("."));
     let root_canon = root.canonicalize().unwrap_or(root);
 
-    let mut gen = Codegen::new_esm(module_canon.clone(), root_canon.clone(), import_rewrite);
+    let mut gen = Codegen::new_esm(
+        module_canon.clone(),
+        root_canon.clone(),
+        import_rewrite,
+        jsx_import_source.to_string(),
+    );
     if source_map {
         let stmt_sources = vec![module_canon.clone(); program.statements.len()];
         let mut builder = SourceMapBuilder::new(Some("module.js"));

package/crates/tish_compile_js/src/lib.rs

@@ -10,11 +10,14 @@ mod tests_jsx;
 pub use codegen::{
     compile_module_esm, compile_project_esm, compile_project_with_jsx,
     compile_project_with_jsx_and_source_map, compile_with_jsx, EmittedJsModule, ImportRewrite,
-    JsBundle,
+    JsBundle, DEFAULT_JSX_IMPORT_SOURCE,
 };
 pub use error::CompileError;
 
-/// JSX lowers to `h` / `Fragment`; merge the `lattish` runtime for hooks and DOM.
+/// Compile a single program to a bundle-style JS string. JSX lowers to `h` / `Fragment`; in bundle
+/// mode those resolve against the merged scope (merge the `lattish` runtime for hooks and DOM). The
+/// per-module ESM paths ([`compile_module_esm`] / [`compile_project_esm`]) auto-import the runtime
+/// for JSX modules that don't import it themselves (issue #291).
 pub fn compile(program: &tishlang_ast::Program, optimize: bool) -> Result<String, CompileError> {
     compile_with_jsx(program, optimize)
 }

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -475,7 +475,8 @@ fn factory() {
             f.write_all(src.as_bytes()).unwrap();
             f.sync_all().unwrap();
         }
-        compile_project_esm(&dir.join(entry), Some(dir), false).expect("compile_project_esm failed")
+        compile_project_esm(&dir.join(entry), Some(dir), false, "lattish")
+            .expect("compile_project_esm failed")
     }
 
     fn module_js<'a>(mods: &'a [EmittedJsModule], rel: &str) -> &'a str {
@@ -557,6 +558,7 @@ fn factory() {
             &base.join("app/src/main.tish"),
             Some(&base.join("app")),
             false,
+            "lattish",
         )
         .expect("compile_project_esm failed for sibling dep");
         let rels: Vec<String> = mods
@@ -607,7 +609,7 @@ fn factory() {
             "import { ping } from \"pkg\"\nconsole.log(ping())\n",
         )
         .unwrap();
-        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false)
+        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false, "lattish")
             .expect("compile_project_esm failed for node_modules dep");
         let rels: Vec<String> = mods
             .iter()
@@ -635,7 +637,7 @@ fn factory() {
         let dir = tmp.path();
         let p = dir.join("main.tish");
         std::fs::write(&p, "import { readFile } from \"fs\"\nconsole.log(1)\n").unwrap();
-        let err = compile_project_esm(&p, Some(dir), false).unwrap_err();
+        let err = compile_project_esm(&p, Some(dir), false, "lattish").unwrap_err();
         assert!(
             err.message.contains("Native module import") && err.message.contains("esm"),
             "expected a native-import rejection for ESM, got: {}",
@@ -665,6 +667,7 @@ fn factory() {
             false,
             ImportRewrite::ViteDev,
             false,
+            "lattish",
         )
         .expect("compile_module_esm failed")
         .js
@@ -741,7 +744,7 @@ fn factory() {
         let dir = tmp.path();
         let p = dir.join("main.tish");
         std::fs::write(&p, "import { readFile } from \"fs\"\nconsole.log(1)\n").unwrap();
-        let err = compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, false)
+        let err = compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, false, "lattish")
             .unwrap_err();
         assert!(
             err.message.contains("Native module import"),
@@ -758,7 +761,8 @@ fn factory() {
         std::fs::write(&p, "export fn greet(n) { return \"hi \" + n }\nconsole.log(greet(\"x\"))\n")
             .unwrap();
         let bundle =
-            compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, true).unwrap();
+            compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, true, "lattish")
+                .unwrap();
         let map = bundle
             .source_map_json
             .expect("source map requested → must be present");
@@ -782,7 +786,8 @@ fn factory() {
         let src = "export fn greet(n) { return \"hi \" + n }\n";
         std::fs::write(&p, src).unwrap();
         let bundle =
-            compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, true).unwrap();
+            compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, true, "lattish")
+                .unwrap();
         let map = bundle.source_map_json.expect("source map requested");
         assert!(
             map.contains("\"sourcesContent\""),
@@ -800,7 +805,7 @@ fn factory() {
         let dir = tmp.path();
         let p = dir.join("main.tish");
         std::fs::write(&p, "console.log(1)\n").unwrap();
-        let err = compile_module_esm(&p, Some(dir), true, ImportRewrite::ViteDev, true)
+        let err = compile_module_esm(&p, Some(dir), true, ImportRewrite::ViteDev, true, "lattish")
             .unwrap_err();
         assert!(
             err.message.to_lowercase().contains("optimiz"),
@@ -808,4 +813,167 @@ fn factory() {
             err.message
         );
     }
+
+    // ── #291: JSX runtime auto-import (h / Fragment) for per-module ESM ────────────────────────
+
+    #[test]
+    fn compile_module_esm_jsx_auto_imports_h() {
+        // A module that uses a JSX element but never imports `h` must get the runtime auto-imported,
+        // or it throws `ReferenceError: h` at load in per-module ESM (issue #291).
+        let js = build_module_vite("main.tish", &[("main.tish", "fn X() { return <div/> }\n")]);
+        assert!(
+            js.contains("import { h } from \"lattish\";"),
+            "JSX element module must auto-import h:\n{js}"
+        );
+        assert!(
+            !js.contains("Fragment"),
+            "no fragment used → Fragment must not be imported:\n{js}"
+        );
+        assert!(js.contains("h(\"div\""), "JSX still lowers to h(...):\n{js}");
+    }
+
+    #[test]
+    fn compile_module_esm_jsx_auto_imports_fragment() {
+        // A fragment lowers to `h(Fragment, …)`, so both `h` and `Fragment` must be auto-imported.
+        let js = build_module_vite(
+            "main.tish",
+            &[("main.tish", "fn X() { return <>{\"a\"}</> }\n")],
+        );
+        assert!(
+            js.contains("import { h, Fragment } from \"lattish\";"),
+            "fragment module must auto-import both h and Fragment:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_jsx_skips_import_when_present() {
+        // An explicit `import { h, Fragment } from "lattish"` must not be duplicated.
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { h, Fragment } from \"lattish\"\nfn X() { return <></> }\n",
+            )],
+        );
+        assert_eq!(
+            js.matches("from \"lattish\"").count(),
+            1,
+            "exactly one lattish import (the author's), no auto-import duplicate:\n{js}"
+        );
+        assert!(
+            js.contains("import { h, Fragment } from \"lattish\";"),
+            "the author's import is preserved:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_jsx_partial_import_extends() {
+        // The author imported only `h`; a fragment also needs `Fragment`, so just that one missing
+        // binding is auto-imported (no re-import of `h`).
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { h } from \"lattish\"\nfn X() { return <></> }\n",
+            )],
+        );
+        assert!(
+            js.contains("import { Fragment } from \"lattish\";"),
+            "only the missing Fragment binding is auto-imported:\n{js}"
+        );
+        assert!(
+            js.contains("import { h } from \"lattish\";"),
+            "the author's h import is preserved:\n{js}"
+        );
+        assert!(
+            !js.contains("import { h, Fragment }"),
+            "h must not be re-imported alongside Fragment:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_vite_dev_jsx_keeps_bare_runtime_import() {
+        // In Vite-dev mode the auto-import specifier stays the bare package so Node/Vite resolves it
+        // (it is NOT rewritten to a relative `.js` path the way disk ESM does).
+        let js = build_module_vite("main.tish", &[("main.tish", "fn X() { return <div/> }\n")]);
+        assert!(
+            js.contains("from \"lattish\";"),
+            "Vite dev keeps the bare runtime specifier:\n{js}"
+        );
+        assert!(
+            !js.contains("lattish.js") && !js.contains("./lattish"),
+            "Vite dev must not rewrite the runtime specifier to a path:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_jsx_import_source_is_configurable() {
+        // The runtime package is overridable (e.g. the scoped `@tishlang/lattish`, or a custom runtime).
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "fn X() { return <div/> }\n").unwrap();
+        let js = compile_module_esm(
+            &p,
+            Some(dir),
+            false,
+            ImportRewrite::ViteDev,
+            false,
+            "@tishlang/lattish",
+        )
+        .expect("compile_module_esm failed")
+        .js;
+        assert!(
+            js.contains("import { h } from \"@tishlang/lattish\";"),
+            "custom jsx import source used:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_project_esm_jsx_auto_import_per_module() {
+        // Only the module that actually uses JSX gets the runtime import; plain modules are untouched.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let base = tmp.path();
+        std::fs::create_dir_all(base.join("src")).unwrap();
+        std::fs::create_dir_all(base.join("node_modules/lattish")).unwrap();
+        std::fs::write(
+            base.join("node_modules/lattish/package.json"),
+            "{\"name\":\"lattish\",\"main\":\"index.tish\"}\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("node_modules/lattish/index.tish"),
+            "export fn h(tag, props, children) { return tag }\nexport let Fragment = \"frag\"\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/view.tish"),
+            "export fn V() { return <div/> }\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/plain.tish"),
+            "export fn add(a, b) { return a + b }\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/main.tish"),
+            "import { V } from \"./view.tish\"\nimport { add } from \"./plain.tish\"\nconsole.log(add(1, 2))\n",
+        )
+        .unwrap();
+        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false, "lattish")
+            .expect("compile_project_esm failed");
+        // The runtime isn't imported by any module, so it's not in the graph; the common-ancestor
+        // output base is `src/`, making the emitted paths flat (`view.js`, `plain.js`, `main.js`).
+        let view = module_js(&mods, "view.js");
+        let plain = module_js(&mods, "plain.js");
+        assert!(
+            view.contains("import { h } from") && view.contains("lattish"),
+            "JSX module auto-imports the runtime:\n{view}"
+        );
+        assert!(
+            !plain.contains("import { h }") && !plain.contains("Fragment"),
+            "non-JSX module must not get a runtime import:\n{plain}"
+        );
+    }
 }

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -98,6 +98,21 @@ fn resolve_import_to_key(
     ))
 }
 
+/// The module specifier a statement imports/re-exports from, if any — covers both
+/// `import … from "x"` and `export … from "x"` (#305 re-export). Dependency discovery and cycle
+/// detection use this so they follow re-export edges, not just plain imports (otherwise a module
+/// reached only via a re-export would never be loaded).
+fn stmt_module_source(stmt: &Statement) -> Option<&str> {
+    match stmt {
+        Statement::Import { from, .. } => Some(&**from),
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            ExportDeclaration::ReExport { from, .. } => Some(&**from),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
 /// Resolve all modules starting from the entry file. Returns modules in dependency order.
 pub fn resolve_virtual(
     entry_path: &str,
@@ -163,7 +178,7 @@ fn load_module_recursive(
 
     let from_dir = parent_dir(module_path);
     for stmt in &program.statements {
-        if let Statement::Import { from, .. } = stmt {
+        if let Some(from) = stmt_module_source(stmt) {
             if is_native_import(from) {
                 continue;
             }
@@ -217,7 +232,7 @@ fn has_cycle_from(
     visiting: &mut HashSet<usize>,
 ) -> Result<bool, String> {
     for stmt in &program.statements {
-        if let Statement::Import { from, .. } = stmt {
+        if let Some(from) = stmt_module_source(stmt) {
             if is_native_import(from) {
                 continue;
             }
@@ -292,6 +307,40 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                         let default_name = format!("__default_{}", idx);
                         module_exports[idx].insert("default".to_string(), default_name);
                     }
+                    // #305: re-export — map each re-exported name to the DEP's binding (the dep is
+                    // earlier in load order, so its export table is already built). `export *` copies
+                    // every dep export without overriding an explicit one; `export { a as b }` maps
+                    // b -> dep's binding for a. Mirrors `merge_modules` in tish_compile/src/resolve.rs.
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        all,
+                        from,
+                        ..
+                    } => {
+                        let dir = parent_dir(&module.path);
+                        let dep = resolve_import_to_key_for_cycle(from, dir, &path_to_idx)
+                            .ok()
+                            .and_then(|key| path_to_idx.get(&key).copied())
+                            .map(|dep_idx| module_exports[dep_idx].clone());
+                        if let Some(dep) = dep {
+                            if *all {
+                                for (k, v) in &dep {
+                                    module_exports[idx]
+                                        .entry(k.clone())
+                                        .or_insert_with(|| v.clone());
+                                }
+                            }
+                            for spec in specifiers {
+                                if let ImportSpecifier::Named { name, alias, .. } = spec {
+                                    if let Some(binding) = dep.get(name.as_ref()) {
+                                        let export_name =
+                                            alias.as_deref().unwrap_or(name.as_ref()).to_string();
+                                        module_exports[idx].insert(export_name, binding.clone());
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -440,6 +489,10 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                             span: espan,
                         });
                     }
+                    // #305: re-export emits no code — `module_exports` already maps the re-exported
+                    // names to the dep's bindings (in scope in the flattened bundle), so downstream
+                    // imports resolve directly. Nothing to push here.
+                    ExportDeclaration::ReExport { .. } => {}
                 },
                 _ => statements.push(stmt.clone()),
             }
@@ -471,4 +524,49 @@ mod tests {
         let program = merge_modules_virtual(modules).unwrap();
         assert!(!program.statements.is_empty());
     }
+
+    #[test]
+    fn test_resolve_virtual_reexport_alias() {
+        // #305: `export { add as plus } from "./dep"` re-exports dep's `add` as `plus`; a downstream
+        // `import { plus }` must resolve to dep's binding. Regression guard: the merge previously did
+        // not handle `ExportDeclaration::ReExport` (E0004 build failure), and discovery did not follow
+        // the re-export edge (so a dep reached only via re-export was never loaded).
+        let mut files = HashMap::new();
+        files.insert(
+            "dep.tish".to_string(),
+            "export fn add(a, b) { return a + b }".to_string(),
+        );
+        files.insert(
+            "mid.tish".to_string(),
+            "export { add as plus } from \"./dep.tish\"".to_string(),
+        );
+        files.insert(
+            "main.tish".to_string(),
+            "import { plus } from \"./mid.tish\"\nconsole.log(plus(1, 2))".to_string(),
+        );
+        let modules = resolve_virtual("main.tish", &files).unwrap();
+        // dep.tish is reached ONLY via mid's re-export → discovery must have loaded it.
+        assert!(
+            modules.iter().any(|m| m.path == "dep.tish"),
+            "re-exported dep should be discovered and loaded"
+        );
+        detect_cycles_virtual(&modules).unwrap();
+        let program = merge_modules_virtual(modules).unwrap();
+        let has_add_fn = program
+            .statements
+            .iter()
+            .any(|s| matches!(s, Statement::FunDecl { name, .. } if name.as_ref() == "add"));
+        let binds_plus_to_add = program.statements.iter().any(|s| {
+            matches!(
+                s,
+                Statement::VarDecl { name, init: Some(Expr::Ident { name: src, .. }), .. }
+                if name.as_ref() == "plus" && src.as_ref() == "add"
+            )
+        });
+        assert!(has_add_fn, "dep's `add` fn should be in the merged bundle");
+        assert!(
+            binds_plus_to_add,
+            "import of re-exported `plus` should bind to dep's `add`"
+        );
+    }
 }

package/crates/tish_core/Cargo.toml

@@ -25,6 +25,10 @@ smallvec = "1"
 indexmap = "2"
 # Fast integer→decimal for the JSON.stringify number fast-path (already in the workspace lock).
 itoa = "1"
+# Fast shortest-float→decimal for the number→string general path (JSON/template/log). ryu writes the
+# shortest round-trip digits straight to a buffer with none of `core::fmt`'s `{:e}` Formatter overhead
+# (profiled as ~40% of JSON.stringify self-time on numeric payloads). Already in the workspace lock.
+ryu = "1"
 fancy-regex = { version = "0.17.0", optional = true }
 # Only under `send-values` (the Arc<Mutex> path): parking_lot's uncontended lock is a
 # single atomic with no pthread syscall — profiled as a top cost on object/array access.