@tishlang/tish-format 2.12.0 → 2.35.0

package/crates/tish_compile/tests/perf_codegen_181.rs

@@ -0,0 +1,36 @@
+//! #181 — direct Map method dispatch for `new Map()` locals.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+fn enable_typed_flags() {
+}
+
+#[test]
+fn k_nucleotide_uses_direct_map_has_get_set() {
+    enable_typed_flags();
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest
+        .join("../../tests/perf/k_nucleotide.tish")
+        .canonicalize()
+        .unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    assert!(
+        rust.contains("tish_map_has("),
+        "expected direct map_has dispatch:\n{}",
+        rust.lines()
+            .filter(|l| l.contains("map_has") || l.contains("map_set"))
+            .take(6)
+            .collect::<Vec<_>>()
+            .join("\n")
+    );
+    assert!(
+        rust.contains("tish_map_get(") && rust.contains("tish_map_set("),
+        "expected direct map_get/set dispatch"
+    );
+    assert!(
+        !rust.contains("get_prop(&(m).clone(), \"has\")"),
+        "should not use bound-method has on map local m"
+    );
+}

package/crates/tish_compile/tests/perf_codegen_320.rs

@@ -0,0 +1,211 @@
+//! #320 — honest native-array lowering for fn-call-built numeric arrays.
+//!
+//! Two sound, name-independent inference fixes:
+//!   fix1: a 0-param numeric fn (`nextBase`, mutates a numeric global, returns number) is eligible
+//!         for native `-> f64` promotion (`collect_native_fns` no longer requires ≥1 param).
+//!   fix2: a fn PROVEN to always return a number lets `infer_expr_type(f(...))` be `number`, so
+//!         `seq.push(nextBase())` keeps `seq` a native `Vec<f64>` instead of a boxed `Value[]`.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+/// The general typed-native inference flags.
+fn enable_typed_flags() {
+}
+
+/// Write `src` under the workspace `target/` (scratch lives there, per repo convention) and compile.
+fn compile_src(stem: &str, src: &str) -> String {
+    let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/perf_codegen_320");
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join(format!("{stem}.tish"));
+    std::fs::write(&path, src).unwrap();
+    let path = path.canonicalize().unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    rust
+}
+
+const NON_ESCAPING: &str = r#"
+let seed = 7
+function nextBase() {
+  seed = (seed * 3877 + 29573) % 139968
+  if (seed < 34992) { return 0 }
+  if (seed < 69984) { return 1 }
+  if (seed < 104976) { return 2 }
+  return 3
+}
+let seq = []
+for (let i = 0; i < 100; i++) { seq.push(nextBase()) }
+let sum = 0
+for (let i = 0; i < seq.length; i++) { sum = sum + seq[i] }
+console.log("R " + sum)
+"#;
+
+#[test]
+fn zero_param_numeric_fn_goes_native() {
+    enable_typed_flags();
+    let rust = compile_src("zero_param", NON_ESCAPING);
+    // fix1: the 0-param fn is promoted to a native `-> f64` form.
+    assert!(
+        rust.contains("fn nextBase_native() -> f64"),
+        "0-param numeric fn should get a native f64 form (fix1)"
+    );
+}
+
+#[test]
+fn numeric_returning_fn_keeps_pushed_array_native() {
+    enable_typed_flags();
+    let rust = compile_src("native_push", NON_ESCAPING);
+    // fix2: `seq.push(nextBase())` keeps `seq` a native `Vec<f64>` (the pushed value infers numeric).
+    assert!(
+        rust.contains("let mut seq: Vec<f64>"),
+        "seq built by push(numericFn()) should be a native Vec<f64> (fix2)"
+    );
+    // And the push routes straight to the native fn (no boxed Value array push).
+    assert!(
+        rust.contains("seq.push(nextBase_native())"),
+        "push should call the native fn into the native Vec (fix1+fix2)"
+    );
+}
+
+/// A fn that can fall through to an implicit `undefined` (no trailing unconditional return) must NOT
+/// be treated as number-returning — else `a.push(maybe())` could put `undefined` in a `Vec<f64>`.
+#[test]
+fn fallthrough_fn_is_not_number_returning() {
+    enable_typed_flags();
+    let src = r#"
+let g = 0
+function maybe() {
+  g = g + 1
+  if (g < 10) { return 1 }
+}
+let a = []
+for (let i = 0; i < 100; i++) { a.push(maybe()) }
+let sum = 0
+for (let i = 0; i < a.length; i++) { sum = sum + 1 }
+console.log("R " + sum)
+"#;
+    let rust = compile_src("fallthrough", src);
+    // Unsound to type `a` as Vec<f64> here — it must stay a boxed array.
+    assert!(
+        !rust.contains("let mut a: Vec<f64>"),
+        "fall-through fn must not make the pushed array native (soundness)"
+    );
+}
+
+/// #320 part 2: a read-only `number[]` param of a normal (boxed-body, boxed-return) fn is unboxed
+/// once into an owned native `Vec<f64>`, so the body indexes it natively. This is the
+/// cross-fn-boundary lever — `kNucleotide(seq, k)` indexes `seq` but builds & returns a boxed Map,
+/// so it is NOT a native-vec fn.
+fn enable_arr_param() {}
+
+const ARR_PARAM: &str = r#"
+let seed = 7
+function nextBase() {
+  seed = (seed * 3877 + 29573) % 139968
+  if (seed < 34992) { return 0 }
+  if (seed < 69984) { return 1 }
+  if (seed < 104976) { return 2 }
+  return 3
+}
+function count(seq, k) {
+  let m = new Map()
+  let n = seq.length - k + 1
+  for (let i = 0; i < n; i++) {
+    let key = 0
+    for (let j = 0; j < k; j++) { key = key * 4 + seq[i + j] }
+    if (m.has(key)) { m.set(key, m.get(key) + 1) } else { m.set(key, 1) }
+  }
+  return m
+}
+let seq = []
+for (let i = 0; i < 100; i++) { seq.push(nextBase()) }
+let m = count(seq, 4)
+let sum = 0
+for (let v of m.values()) { sum = sum + v }
+console.log("R " + sum)
+"#;
+
+#[test]
+fn readonly_arr_param_unboxed_to_native_vec() {
+    enable_arr_param();
+    let rust = compile_src("arr_param", ARR_PARAM);
+    // The `seq` param is unboxed once into an owned native Vec<f64> at the closure entry (a packed
+    // NumberArray clones its backing; a boxed Array is mapped element-wise).
+    assert!(
+        rust.contains("let mut seq: Vec<f64> = match args.get(")
+            && rust.contains("Some(Value::NumberArray(a)) => a.borrow().clone()"),
+        "read-only number[] param should be unboxed to a native Vec<f64>"
+    );
+    // And the hot inner loop indexes it natively (f64 mul + native vec read), no boxed get_index.
+    assert!(
+        rust.contains("key * 4_f64") && rust.contains("seq.get("),
+        "inner loop should be native f64 arithmetic over a native Vec read"
+    );
+    assert!(
+        !rust.contains("tishlang_runtime::get_index(&seq")
+            && !rust.contains("get_index(&(seq)"),
+        "seq must not be read via the boxed runtime get_index inside the fn"
+    );
+}
+
+#[test]
+fn mutating_arr_param_stays_boxed() {
+    enable_arr_param();
+    // `a` is index-ASSIGNED → an owned native copy would silently drop the write, so the param must
+    // stay boxed (classify_vec_param reports is_mut, and the detection requires read-only).
+    let src = r#"
+function bump(a) { a[0] = a[0] + 1; return a.length }
+let arr = []
+for (let i = 0; i < 10; i++) { arr.push(i) }
+let r = bump(arr)
+console.log("R " + r)
+"#;
+    let rust = compile_src("mut_arr_param", src);
+    assert!(
+        !rust.contains("let mut a: Vec<f64>"),
+        "a mutated array param must stay boxed (soundness — owned copy would lose writes)"
+    );
+}
+
+#[test]
+fn escaping_arr_param_stays_boxed() {
+    enable_arr_param();
+    // `seq.push` MUTATES the param via a method (not index-assign): an owned copy would lose the
+    // caller-visible push. `scan_param_use` flags this as an escape → the param stays boxed.
+    let src = r#"
+function build(seq) {
+  let m = new Map()
+  for (let i = 0; i < seq.length; i++) { m.set(i, seq[i]) }
+  seq.push(99)
+  return m
+}
+let arr = []
+for (let i = 0; i < 10; i++) { arr.push(i) }
+let m = build(arr)
+console.log("R " + arr.length)
+"#;
+    let rust = compile_src("escape_arr_param", src);
+    assert!(
+        !rust.contains("let mut seq: Vec<f64>"),
+        "an escaping (pushed) array param must stay boxed (soundness)"
+    );
+}
+
+#[test]
+fn non_number_array_arg_keeps_callee_boxed() {
+    enable_arr_param();
+    // `joinup` reads its param read-only, but the ONLY caller passes a NON-number[] array. Unboxing
+    // to Vec<f64> would turn "x" into NaN (vs JS string concat) — so the call-site check keeps the
+    // callee fully boxed.
+    let src = r#"
+function joinup(seq) { let r = ""; for (let i = 0; i < seq.length; i++) { r = r + seq[i] } return r }
+let arr = [1, "x", 3]
+console.log(joinup(arr))
+"#;
+    let rust = compile_src("nonnum_arr_arg", src);
+    assert!(
+        !rust.contains("let mut seq: Vec<f64>"),
+        "a read-only fn whose caller passes a non-number[] array must stay boxed (call-site soundness)"
+    );
+}

package/crates/tish_compile/tests/perf_codegen_module_const_forof.rs

@@ -0,0 +1,40 @@
+//! Hoisted module-level f64 array literals (`const G_XS`) must compile when used in for-of / join.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+#[test]
+fn typed_array_forof_compiles() {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest
+        .join("../../tests/core/typed_array_forof.tish")
+        .canonicalize()
+        .unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    assert!(rust.contains("const G_XS:"), "expected hoisted xs array");
+    assert!(
+        !rust.contains("normalize_for_of((xs)"),
+        "for-of should use native index loop over G_XS, not boxed xs reference"
+    );
+    assert!(
+        rust.contains("for _fof_i0 in 0..G_XS.len()"),
+        "expected native for-of over hoisted G_XS"
+    );
+}
+
+#[test]
+fn template_literals_hoisted_nums_compiles() {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest
+        .join("../../tests/core/template_literals.tish")
+        .canonicalize()
+        .unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    assert!(rust.contains("const G_NUMS:"));
+    assert!(
+        rust.contains("array_join(&Value::NumberArray(VmRef::new(G_NUMS"),
+        "nums.join should box hoisted G_NUMS, not reference missing local nums"
+    );
+    assert!(!rust.contains("&nums,"));
+}

package/crates/tish_compile_js/src/codegen.rs

@@ -376,6 +376,19 @@ impl Codegen {
                 self.writeln(&format!("for (const {} of {})", escaped, it));
                 self.emit_js_control_body(body)?;
             }
+            Statement::ForIn {
+                name,
+                object,
+                body,
+                ..
+            } => {
+                // Native JS `for-in` — iterates own enumerable keys (#413). tish objects have no
+                // prototype chain, so this matches the key-enumeration the other backends perform.
+                let escaped = Self::escape_ident(name.as_ref());
+                let obj = self.emit_expr(object)?;
+                self.writeln(&format!("for (const {} in {})", escaped, obj));
+                self.emit_js_control_body(body)?;
+            }
             Statement::Return { value, .. } => {
                 if let Some(v) = value {
                     let e = self.emit_expr(v)?;
@@ -677,6 +690,14 @@ impl Codegen {
             }
             Expr::Call { callee, args, .. } => {
                 let c = self.emit_expr(callee)?;
+                // An arrow-function callee (an IIFE — `(function(x){…})(n)` lowers to an arrow, as does
+                // `((x)=>…)(n)`) must be parenthesized: without it the call `(args)` binds to the arrow
+                // BODY, not the whole arrow — a `SyntaxError` for a block body, wrong result otherwise.
+                let c = if matches!(&**callee, Expr::ArrowFunction { .. }) {
+                    format!("({})", c)
+                } else {
+                    c
+                };
                 let arg_strs: Result<Vec<_>, _> =
                     args.iter().map(|a| self.emit_call_arg(a)).collect();
                 let arg_strs = arg_strs?.join(", ");
@@ -889,7 +910,9 @@ impl Codegen {
                 let val = self.emit_expr(value)?;
                 format!("({}[{}] = {})", obj, idx, val)
             }
-            Expr::ArrowFunction { params, body, .. } => {
+            Expr::ArrowFunction {
+                async_, params, body, ..
+            } => {
                 let ps = self.emit_params(params, None)?;
                 let body_str = match body {
                     ArrowBody::Expr(e) => self.emit_expr(e)?,
@@ -905,10 +928,11 @@ impl Codegen {
                         block
                     }
                 };
+                let prefix = if *async_ { "async " } else { "" }; // #428
                 if matches!(body, ArrowBody::Expr(_)) {
-                    format!("({}) => ({})", ps, body_str)
+                    format!("{}({}) => ({})", prefix, ps, body_str)
                 } else {
-                    format!("({}) => {}", ps, body_str)
+                    format!("{}({}) => {}", prefix, ps, body_str)
                 }
             }
             Expr::TemplateLiteral { quasis, exprs, .. } => {
@@ -1036,6 +1060,52 @@ 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 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()),
+                        }
+                    }
+                }
+                match from {
+                    // Re-export from another module: `export … from "…"`.
+                    Some(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 {
+                            self.writeln(&format!(
+                                "export {{ {} }} from {:?};",
+                                parts.join(", "),
+                                spec
+                            ));
+                        }
+                    }
+                    // #415 local named export — no `from` clause.
+                    None => {
+                        self.writeln(&format!("export {{ {} }};", parts.join(", ")));
+                    }
+                }
+            }
         }
         Ok(())
     }
@@ -1182,6 +1252,7 @@ fn compile_project_js_inner(
         merged.program.clone()
     };
     let stmt_sources = merged.statement_sources;
+    let entry_exports = merged.entry_exports; // #295: entry module's named exports for the bundle
     let default_export = program.statements.iter().find_map(|s| {
         if let Statement::VarDecl { name, .. } = s {
             let n = name.as_ref();
@@ -1221,6 +1292,26 @@ fn compile_project_js_inner(
         gen.emit_program(&program, None, None)?;
     }
     let mut js = gen.output;
+    // #295: re-emit the entry module's named exports as a real ES `export { … }` so the bundle is a
+    // valid ES module (previously only `export default` was emitted; named `export fn/let/{…}` were
+    // silently dropped, forcing downstream regex post-processing).
+    if !entry_exports.is_empty() {
+        let parts: Vec<String> = entry_exports
+            .iter()
+            .map(|(local, exported)| {
+                if local == exported {
+                    Codegen::escape_ident(local)
+                } else {
+                    format!(
+                        "{} as {}",
+                        Codegen::escape_ident(local),
+                        Codegen::escape_ident(exported)
+                    )
+                }
+            })
+            .collect();
+        js.push_str(&format!("\nexport {{ {} }};\n", parts.join(", ")));
+    }
     if let Some(name) = default_export {
         js.push_str(&format!("\nexport default {};\n", name));
     }

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -167,6 +167,33 @@ mod tests {
         let _ = std::fs::remove_file(&path);
     }
 
+    /// #295: `--target js --format bundle` must re-emit the entry module's named exports as a real ES
+    /// `export { … }` (previously only `export default` surfaced; `export fn/const/{…}` were silently
+    /// dropped, forcing downstream regex post-processing of every bundle).
+    #[test]
+    fn bundle_emits_named_exports() {
+        // `tempfile::tempdir()` (RAII, unique dir) rather than a fixed `std::env::temp_dir()` path.
+        let dir = tempfile::tempdir().expect("tempdir");
+        let path = dir.path().join("entry.tish");
+        let src = "export fn mountFoo(h) { return h }\n\
+                   export const VERSION = \"1\"\n\
+                   fn helper() { return 2 }\n\
+                   export { helper as helperExported }\n\
+                   export default 42\n";
+        std::fs::write(&path, src).unwrap();
+        let js = compile_project_with_jsx(&path, Some(dir.path()), false)
+            .expect("compile_project_with_jsx failed");
+        assert!(
+            js.contains("export { VERSION, helper as helperExported, mountFoo };"),
+            "bundle must emit named exports, got:\n{}",
+            &js[js.len().saturating_sub(300)..]
+        );
+        assert!(
+            js.contains("export default __default_0;"),
+            "bundle must still emit the default export"
+        );
+    }
+
     #[test]
     fn jsx_never_emits_vdom_helpers_or_prelude_flags() {
         let src = r#"fn X() { return <div class="x">{"a"}</div> }"#;

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -98,6 +98,22 @@ 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() {
+            // A local named export (`export { a }`, from=None) has no module dependency.
+            ExportDeclaration::ReExport { from, .. } => from.as_deref(),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
 /// Resolve all modules starting from the entry file. Returns modules in dependency order.
 pub fn resolve_virtual(
     entry_path: &str,
@@ -163,7 +179,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 +233,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 +308,54 @@ 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: Some(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());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // #415 local named export (no `from`): map each export name to the local binding.
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        from: None,
+                        ..
+                    } => {
+                        for spec in specifiers {
+                            if let ImportSpecifier::Named { name, alias, .. } = spec {
+                                let export_name =
+                                    alias.as_deref().unwrap_or(name.as_ref()).to_string();
+                                module_exports[idx].insert(export_name, name.to_string());
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -440,6 +504,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 +539,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.