@tishlang/tish 2.9.0 → 2.10.1

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "2.9.0"
+version = "2.10.1"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }
@@ -59,6 +59,7 @@ tishlang_runtime = { path = "../tish_runtime", version = ">=0.1" }
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 tishlang_js_to_tish = { path = "../js_to_tish", version = ">=0.1" }
 clap = { version = "4.6.0", features = ["derive", "color"] }
+serde_json = "1"
 tishlang_pg = { path = "../tish_pg", version = ">=0.1", optional = true }
 mimalloc = { version = "0.1", optional = true }
 

package/crates/tish/src/cli_help.rs

@@ -571,6 +571,34 @@ pub(crate) struct BuildArgs {
     pub file: String,
 }
 
+#[derive(Parser)]
+pub(crate) struct CompileModuleArgs {
+    /// `--target js` only (the single-module ESM path is JS-specific).
+    #[arg(long, default_value = "js", value_name = "TARGET", help_heading = "Options")]
+    pub target: String,
+    /// `--format esm` only (one ES module per file).
+    #[arg(long, default_value = "esm", value_name = "FORMAT", help_heading = "Options")]
+    pub format: String,
+    /// Keep relative `.tish` specifiers and bare packages verbatim so Vite's resolveId/load re-enters the plugin per module (in-graph HMR). Omit for disk-style `.tish`->`.js` rewriting.
+    #[arg(long, help_heading = "Options")]
+    pub vite_dev: bool,
+    /// Emit a v3 source map back to the `.tish` source as a `{ "js", "map" }` JSON envelope on stdout (on by default; implies no optimization).
+    #[arg(long, help_heading = "Options")]
+    pub source_map: bool,
+    /// Disable the source map; print raw ES module JS to stdout instead of the JSON envelope.
+    #[arg(long = "no-source-map", help_heading = "Options")]
+    pub no_source_map: bool,
+    /// Project root for resolving bare specifiers / `node_modules` (defaults to the file's parent).
+    #[arg(long, value_name = "DIR", help_heading = "Options")]
+    pub project_root: Option<String>,
+    /// Disable AST optimizations (forced on when a source map is emitted).
+    #[arg(long, help_heading = "Options")]
+    pub no_optimize: bool,
+    /// Entry `.tish` file to compile (only this file is read; dependencies are left to the bundler).
+    #[arg(required = true, value_name = "FILE", help_heading = "Arguments")]
+    pub file: String,
+}
+
 #[derive(Subcommand)]
 pub(crate) enum Commands {
     /// Run a Tish file (interpret)
@@ -579,6 +607,9 @@ pub(crate) enum Commands {
     Repl(ReplArgs),
     /// Build native binary, wasm, wasi, or JavaScript output
     Build(BuildArgs),
+    /// Compile a single `.tish` module to one ES module (for Vite dev / HMR); prints to stdout
+    #[command(name = "compile-module")]
+    CompileModule(CompileModuleArgs),
     /// Parse and dump AST
     #[command(name = "dump-ast")]
     DumpAst {

package/crates/tish/src/main.rs

@@ -22,7 +22,7 @@ use tishlang_core::VmRef;
 use clap::FromArgMatches;
 use rustyline::{Behavior, ColorMode, CompletionType, Config, Editor};
 
-use cli_help::{Cli, Commands};
+use cli_help::{Cli, Commands, CompileModuleArgs};
 
 /// Normalize `--feature` / `--feature http,timers,fs` / `--feature full` for VM runs and native builds.
 fn normalize_capability_flags(features: &[String]) -> HashSet<String> {
@@ -73,7 +73,7 @@ fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
 fn argv_with_implicit_run(mut argv: Vec<String>) -> Vec<String> {
     if argv.len() >= 2 {
         let first = argv[1].as_str();
-        const SUBCOMMANDS: &[&str] = &["run", "repl", "build", "dump-ast"];
+        const SUBCOMMANDS: &[&str] = &["run", "repl", "build", "compile-module", "dump-ast"];
         let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.contains(&first);
         if looks_like_file {
             argv.insert(1, "run".to_string());
@@ -139,6 +139,7 @@ fn main() {
                 &a.format,
             )
         }
+        Some(Commands::CompileModule(a)) => compile_module(&a),
         Some(Commands::DumpAst {
             file,
             ignore_indent,
@@ -703,6 +704,71 @@ fn compile_to_js_esm(
     Ok(())
 }
 
+/// `tish compile-module FILE` (#284): compile a single `.tish` file to one ES module and print it
+/// to stdout. This is the fast, in-graph path the Vite plugin shells out to in `load()` — only the
+/// one file is read (no dependency graph resolution), so Vite owns the module graph and can HMR a
+/// leaf module without a full reload.
+///
+/// With a source map (default), stdout is a JSON envelope `{"js":…,"map":…}` so the plugin gets
+/// both artifacts from one spawn; with `--no-source-map`, stdout is raw ES module JS.
+fn compile_module(args: &CompileModuleArgs) -> Result<(), String> {
+    if args.target != "js" {
+        return Err(format!(
+            "tish compile-module only supports --target js (got '{}').",
+            args.target
+        ));
+    }
+    if args.format != "esm" {
+        return Err(format!(
+            "tish compile-module only supports --format esm (got '{}').",
+            args.format
+        ));
+    }
+    let input_path = Path::new(&args.file)
+        .canonicalize()
+        .map_err(|e| format!("Cannot resolve {}: {}", args.file, e))?;
+    if input_path.extension().map(|e| e != "tish").unwrap_or(true) {
+        return Err(format!(
+            "tish compile-module expects a .tish file (got '{}').",
+            args.file
+        ));
+    }
+    let want_map = !args.no_source_map;
+    // A source map needs unmerged statement order, so it forces no optimization (same rule as
+    // `build --target js --source-map`).
+    let optimize = !args.no_optimize && !want_map;
+    let import_rewrite = if args.vite_dev {
+        tishlang_compile_js::ImportRewrite::ViteDev
+    } else {
+        tishlang_compile_js::ImportRewrite::Disk
+    };
+    let project_root = args
+        .project_root
+        .as_ref()
+        .map(PathBuf::from)
+        .or_else(|| input_path.parent().map(Path::to_path_buf));
+    let bundle = tishlang_compile_js::compile_module_esm(
+        &input_path,
+        project_root.as_deref(),
+        optimize,
+        import_rewrite,
+        want_map,
+    )
+    .map_err(|e| format!("{}", e))?;
+
+    if let Some(map_json) = bundle.source_map_json {
+        let map: serde_json::Value = serde_json::from_str(&map_json)
+            .map_err(|e| format!("Internal: source map is not valid JSON: {}", e))?;
+        let envelope = serde_json::json!({ "js": bundle.js, "map": map });
+        let line = serde_json::to_string(&envelope)
+            .map_err(|e| format!("Cannot serialize compile-module output: {}", e))?;
+        println!("{}", line);
+    } else {
+        print!("{}", bundle.js);
+    }
+    Ok(())
+}
+
 #[allow(clippy::vec_init_then_push, clippy::too_many_arguments)] // build_file maps CLI build flags 1:1
 fn build_file(
     input_path: &str,

package/crates/tish/tests/integration_test.rs

@@ -738,6 +738,114 @@ fn test_js_esm_export_collision() {
     }
 }
 
+/// #284: `tish compile-module --vite-dev --source-map` compiles a single `.tish` file (no graph
+/// resolution) to one ES module, keeps relative `.tish` specifiers, and emits a `{ js, map }` JSON
+/// envelope whose map references the `.tish` source. This is the in-graph path the Vite plugin uses.
+#[test]
+fn test_compile_module_vite_dev_with_source_map() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let main = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("vite_hmr")
+        .join("main.tish");
+    if !main.exists() {
+        return;
+    }
+    let out = Command::new(&bin)
+        .args(["compile-module"])
+        .arg(&main)
+        .args([
+            "--target",
+            "js",
+            "--format",
+            "esm",
+            "--vite-dev",
+            "--source-map",
+        ])
+        .current_dir(workspace_root())
+        .output()
+        .expect("run compile-module");
+    assert!(
+        out.status.success(),
+        "compile-module failed: stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let parsed: serde_json::Value =
+        serde_json::from_str(&stdout).unwrap_or_else(|e| panic!("stdout is not JSON: {e}\n{stdout}"));
+    let js = parsed["js"].as_str().expect("envelope has string `js`");
+    assert!(
+        js.contains("import { makeCounter } from \"./counter.tish\";"),
+        "Vite-dev keeps the .tish specifier:\n{js}"
+    );
+    assert!(
+        !js.contains("./counter.js"),
+        "Vite-dev must not rewrite .tish to .js:\n{js}"
+    );
+    let map = &parsed["map"];
+    assert!(map.is_object(), "envelope has object `map`: {map}");
+    assert_eq!(map["version"], serde_json::json!(3), "v3 source map");
+    let sources = map["sources"].as_array().expect("map has sources");
+    assert!(
+        sources
+            .iter()
+            .any(|s| s.as_str().map(|s| s.contains("main.tish")).unwrap_or(false)),
+        "map sources reference the .tish file: {sources:?}"
+    );
+}
+
+/// #284: without `--source-map`, `compile-module` prints raw ES module JS to stdout (no envelope),
+/// so the output can be consumed directly.
+#[test]
+fn test_compile_module_no_source_map_prints_raw_js() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let counter = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("vite_hmr")
+        .join("counter.tish");
+    if !counter.exists() {
+        return;
+    }
+    let out = Command::new(&bin)
+        .args(["compile-module"])
+        .arg(&counter)
+        .args([
+            "--target",
+            "js",
+            "--format",
+            "esm",
+            "--vite-dev",
+            "--no-source-map",
+        ])
+        .current_dir(workspace_root())
+        .output()
+        .expect("run compile-module");
+    assert!(
+        out.status.success(),
+        "compile-module failed: stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("export function makeCounter"),
+        "raw JS output includes the export:\n{stdout}"
+    );
+    assert!(
+        !stdout.trim_start().starts_with('{'),
+        "no-source-map output is raw JS, not a JSON envelope:\n{stdout}"
+    );
+}
+
 /// Ignored: tishlang_eval::run() does not run the event loop.
 #[test]
 #[cfg(feature = "http")]

package/crates/tish_compile/src/codegen.rs

@@ -2097,6 +2097,148 @@ impl Codegen {
         self.emit_expr(expr)
     }
 
+    /// Is `update` a `+1` step on `var` (`var++`, `++var`, `var += 1`, or `var = var + 1`)?
+    fn is_increment_of(update: &Expr, var: &str) -> bool {
+        match update {
+            Expr::PostfixInc { name, .. } | Expr::PrefixInc { name, .. } => name.as_ref() == var,
+            Expr::CompoundAssign {
+                name,
+                op: CompoundOp::Add,
+                value,
+                ..
+            } => name.as_ref() == var && Self::int_literal_value_of(value) == Some(1),
+            Expr::Assign { name, value, .. } => {
+                name.as_ref() == var
+                    && matches!(
+                        value.as_ref(),
+                        Expr::Binary { left, op: BinOp::Add, right, .. }
+                            if matches!(left.as_ref(), Expr::Ident { name: l, .. } if l.as_ref() == var)
+                                && Self::int_literal_value_of(right) == Some(1)
+                    )
+            }
+            _ => false,
+        }
+    }
+
+    /// #173: detect a fill loop `for (let i = 0; i < N; i++) { a.push(K) }` over a native `Vec<T>`
+    /// and emit it as a single bulk `a.extend(std::iter::repeat(K).take((N) as usize))` — one
+    /// allocation instead of N per-element pushes that repeatedly realloc as the Vec grows. Returns
+    /// `Ok(true)` when the fused form was emitted (the caller then skips the normal loop).
+    ///
+    /// Sound only when `N` is a proven, side-effect-free integer (so the bulk count matches the loop
+    /// iteration count exactly, including the truncating `as usize` for `0`/negative) and `K` is a
+    /// constant of the element type (no per-element variation). Any miss returns `Ok(false)` and the
+    /// normal loop is emitted — correctness over coverage.
+    fn try_emit_native_fill_loop(
+        &mut self,
+        init: Option<&Statement>,
+        cond: Option<&Expr>,
+        update: Option<&Expr>,
+        body: &Statement,
+    ) -> Result<bool, CompileError> {
+        // init: `let i = 0`
+        let (
+            Some(Statement::VarDecl {
+                name: i_name,
+                init: Some(i_init),
+                ..
+            }),
+            Some(cond),
+            Some(update),
+        ) = (init, cond, update)
+        else {
+            return Ok(false);
+        };
+        if Self::int_literal_value_of(i_init) != Some(0) {
+            return Ok(false);
+        }
+        // cond: `i < N`
+        let Expr::Binary {
+            left,
+            op: BinOp::Lt,
+            right: bound,
+            ..
+        } = cond
+        else {
+            return Ok(false);
+        };
+        let Expr::Ident { name: c_name, .. } = left.as_ref() else {
+            return Ok(false);
+        };
+        if c_name.as_ref() != i_name.as_ref() {
+            return Ok(false);
+        }
+        // update: `i++` / `++i` / `i += 1` / `i = i + 1`
+        if !Self::is_increment_of(update, i_name.as_ref()) {
+            return Ok(false);
+        }
+        // body: exactly one statement `a.push(K)`
+        let push_stmt = match body {
+            Statement::Block { statements, .. } if statements.len() == 1 => &statements[0],
+            Statement::ExprStmt { .. } => body,
+            _ => return Ok(false),
+        };
+        let Statement::ExprStmt {
+            expr: Expr::Call { callee, args, .. },
+            ..
+        } = push_stmt
+        else {
+            return Ok(false);
+        };
+        let Expr::Member {
+            object,
+            prop: MemberProp::Name { name: method, .. },
+            optional: false,
+            ..
+        } = callee.as_ref()
+        else {
+            return Ok(false);
+        };
+        if method.as_ref() != "push" || args.len() != 1 {
+            return Ok(false);
+        }
+        let Expr::Ident { name: arr_name, .. } = object.as_ref() else {
+            return Ok(false);
+        };
+        // `a` must be a native `Vec<T>`. A closure-captured (RefCell) Vec would need a borrow_mut;
+        // skip it (rare) and keep the plain loop.
+        let RustType::Vec(elem) = self.type_context.get_type(arr_name.as_ref()) else {
+            return Ok(false);
+        };
+        if self.refcell_wrapped_vars.contains(arr_name.as_ref()) {
+            return Ok(false);
+        }
+        let CallArg::Expr(k_expr) = &args[0] else {
+            return Ok(false);
+        };
+        // K must be a constant literal of the element type (no per-element variation, no `i` ref).
+        let k_code = match (&*elem, k_expr) {
+            (RustType::F64, Expr::Literal { value: Literal::Number(n), .. }) => Self::f64_lit(*n),
+            (RustType::Bool, Expr::Literal { value: Literal::Bool(b), .. }) => format!("{}", b),
+            _ => return Ok(false),
+        };
+        // N must be a proven, side-effect-free integer: an integer literal or an int-range local.
+        let n_code = match bound.as_ref() {
+            Expr::Literal {
+                value: Literal::Number(_),
+                ..
+            } if Self::int_literal_value_of(bound).is_some() => self.emit_typed_expr(bound)?.0,
+            Expr::Ident { name, .. }
+                if self.int_range_locals.contains_key(name.as_ref())
+                    && self.type_context.get_type(name.as_ref()) == RustType::F64 =>
+            {
+                Self::escape_ident(name.as_ref()).into_owned()
+            }
+            _ => return Ok(false),
+        };
+        let arr_esc = Self::escape_ident(arr_name.as_ref()).into_owned();
+        self.writeln(&format!(
+            "{}.extend(std::iter::repeat({}).take(({}) as usize));",
+            arr_esc, k_code, n_code
+        ));
+        Ok(true)
+    }
+
     fn emit_statement(&mut self, stmt: &Statement) -> Result<(), CompileError> {
         match stmt {
             Statement::Block { statements, .. } => {
@@ -2424,6 +2566,18 @@ impl Codegen {
                 body,
                 ..
             } => {
+                // #173: fuse a fill loop `for (let i = 0; i < N; i++) { a.push(K) }` over a native
+                // `Vec<T>` into a single bulk `extend` — one allocation instead of N per-element
+                // pushes (which repeatedly realloc as the Vec grows). Sound only when `N` is a proven,
+                // side-effect-free integer; otherwise the normal loop is emitted below.
+                if self.try_emit_native_fill_loop(
+                    init.as_deref(),
+                    cond.as_ref(),
+                    update.as_ref(),
+                    body,
+                )? {
+                    return Ok(());
+                }
                 self.writeln("{");
                 self.indent += 1;
                 if let Some(i) = init {
@@ -7537,6 +7691,13 @@ impl Codegen {
                 ..
             } => {
                 if let Expr::Ident { name: var_name, .. } = object.as_ref() {
+                    // #173: `vec.length` on a native `Vec<_>` is a native `f64` (the emitter lowers it
+                    // to `(vec.len() as f64)`), so a local fed by `arr.length` stays native.
+                    if let Some(RustType::Vec(_)) = env.get(var_name.as_ref()) {
+                        if prop_name.as_ref() == "length" {
+                            return RustType::F64;
+                        }
+                    }
                     if let Some(RustType::Named { fields, .. }) = env.get(var_name.as_ref()) {
                         if let Some((_, field_ty)) =
                             fields.iter().find(|(k, _)| k.as_ref() == prop_name.as_ref())
@@ -7577,6 +7738,12 @@ impl Codegen {
                         }
                     }
                 }
+                // #169: a fused native `Vec<f64>` reduce produces an `f64` (the emitter lowers it via
+                // `native_vec_hof_for_call`). Model it here so an accumulator fed by `xs.reduce(...)`
+                // is not wrongly demoted to a boxed `Value`. Conservative: any miss → `Value`.
+                if let Some(t) = self.native_vec_reduce_result_type(callee, args, env) {
+                    return t;
+                }
                 RustType::Value
             }
             // Unary, Conditional, etc. are not modelled by `emit_typed_expr` (it boxes them), so a
@@ -7586,6 +7753,81 @@ impl Codegen {
         }
     }
 
+    /// #169: read-only mirror of [`try_native_vec_hof`]'s `reduce` preconditions, for
+    /// [`expr_native_type`]. Returns `Some(F64)` exactly when a `xs.reduce((acc, x) => body, init)`
+    /// call would fuse to a native `f64` fold (so an accumulator it feeds stays native instead of
+    /// being demoted to a boxed `Value`). Any uncertainty returns `None` — the oracle never claims
+    /// `F64` where the emitter would box, which is what keeps the demotion analysis sound.
+    fn native_vec_reduce_result_type(
+        &self,
+        callee: &Expr,
+        args: &[CallArg],
+        env: &HashMap<String, RustType>,
+    ) -> Option<RustType> {
+        if std::env::var("TISH_NATIVE_HOF").is_err() {
+            return None;
+        }
+        let Expr::Member {
+            object,
+            prop: MemberProp::Name { name: method, .. },
+            optional: false,
+            ..
+        } = callee
+        else {
+            return None;
+        };
+        if method.as_ref() != "reduce" {
+            return None;
+        }
+        let Expr::Ident { name: recv_name, .. } = object.as_ref() else {
+            return None;
+        };
+        // Receiver must be a native `Vec<f64>` (`.copied()` needs a `Copy` element).
+        match env.get(recv_name.as_ref()) {
+            Some(RustType::Vec(inner)) if **inner == RustType::F64 => {}
+            _ => return None,
+        }
+        // `reduce(callback, init)` with a simple-param expression-body arrow that does not touch the
+        // receiver (an alias inside the closure would break the `.iter()` borrow).
+        if args.len() != 2 {
+            return None;
+        }
+        let Some(CallArg::Expr(Expr::ArrowFunction { params, body, .. })) = args.first() else {
+            return None;
+        };
+        if params.len() != 2 {
+            return None;
+        }
+        let (FunParam::Simple(acc_p), FunParam::Simple(x_p)) = (&params[0], &params[1]) else {
+            return None;
+        };
+        if acc_p.default.is_some() || x_p.default.is_some() {
+            return None;
+        }
+        let ArrowBody::Expr(be) = body else {
+            return None;
+        };
+        if crate::infer::pi_mentions(be, recv_name.as_ref()) {
+            return None;
+        }
+        // The init must be native-numeric, and the body must lower to `f64` with both closure params
+        // bound `f64` — exactly the emitter's preconditions, evaluated read-only.
+        let CallArg::Expr(init_e) = &args[1] else {
+            return None;
+        };
+        if self.expr_native_type(init_e, env) != RustType::F64 {
+            return None;
+        }
+        let mut benv = env.clone();
+        benv.insert(acc_p.name.to_string(), RustType::F64);
+        benv.insert(x_p.name.to_string(), RustType::F64);
+        if self.expr_native_type(be, &benv) == RustType::F64 {
+            Some(RustType::F64)
+        } else {
+            None
+        }
+    }
+
     /// Names of top-level fns eligible for a parallel native `fn f_native(f64,..)->f64`:
     /// non-async, every param `: number` (no default), `: number` return, and a native-safe
     /// body (only block/if/return/expr-stmt over native exprs + calls to other eligible fns or
@@ -9444,6 +9686,19 @@ impl Codegen {
             } => {
                 if let Expr::Ident { name: var_name, .. } = object.as_ref() {
                     let var_type = self.type_context.get_type(var_name.as_ref());
+                    // #173: `vec.length` on a native `Vec<_>` → `(vec.len() as f64)`, so the length
+                    // (and arithmetic derived from it) stays native instead of a boxed `get_prop`.
+                    if let RustType::Vec(_) = &var_type {
+                        if prop_name.as_ref() == "length" {
+                            let var_esc = Self::escape_ident(var_name.as_ref()).into_owned();
+                            let code = if self.refcell_wrapped_vars.contains(var_name.as_ref()) {
+                                format!("({}.borrow().len() as f64)", var_esc)
+                            } else {
+                                format!("({}.len() as f64)", var_esc)
+                            };
+                            return Ok((code, RustType::F64));
+                        }
+                    }
                     if let RustType::Named { fields, .. } = &var_type {
                         if let Some((_, field_ty)) =
                             fields.iter().find(|(k, _)| k.as_ref() == prop_name.as_ref())

package/crates/tish_compile/tests/perf_codegen_169_173.rs

@@ -0,0 +1,139 @@
+//! Generated-Rust assertions for the Beat-Node native codegen wins #169 and #173.
+//!
+//! These run in their own test binary (separate process from the lib unit tests), so the
+//! dark-ship env flags set here never leak into other tests. Every test sets the SAME flag set
+//! (the gauntlet's `TYPED_FLAGS`), so parallel execution is race-free.
+
+use std::path::PathBuf;
+
+use tishlang_compile::{compile, compile_project_full};
+use tishlang_parser::parse;
+
+/// Enable every dark-shipped typed-native flag, matching `scripts/run_perf_gauntlet.sh`.
+fn enable_typed_flags() {
+    for k in [
+        "TISH_PARAM_NATIVE",
+        "TISH_PARAM_INFER",
+        "TISH_NATIVE_FN",
+        "TISH_STRUCT_INFER",
+        "TISH_FUSED_HOF",
+        "TISH_NATIVE_HOF",
+        "TISH_AGGREGATE_INFER",
+    ] {
+        std::env::set_var(k, "1");
+    }
+}
+
+fn compile_typed(src: &str) -> String {
+    enable_typed_flags();
+    compile(&parse(src).unwrap()).unwrap()
+}
+
+/// Compile a real fixture through the **same** path the `tish build` CLI uses
+/// (`compile_project_full` → `merge_modules` → codegen), so generated-Rust assertions match the
+/// gauntlet build exactly.
+fn compile_fixture_typed(rel: &str) -> String {
+    enable_typed_flags();
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    rust
+}
+
+// ── #169: a fused native `Vec<f64>` reduce result keeps its accumulator native ────────────────
+
+#[test]
+fn issue_169_reduce_fed_accumulator_stays_native() {
+    // The real gauntlet fixture: `acc` is updated from `xs.reduce(...)` (which the native-HOF path
+    // fuses to a native f64 fold). Before #169 the demotion oracle didn't model the fusion, so `acc`
+    // was boxed (`let mut acc = Value::Number(...)`) and paid boxed ops::mul/add/modulo + clone per
+    // iter. Compiled through the same `compile_project_full` path the `tish build` CLI uses.
+    let rust = compile_fixture_typed("tests/perf/typed_array_hof.tish");
+    assert!(
+        rust.contains("let mut acc: f64"),
+        "acc must stay native f64 (reduce result modelled as F64), got:\n{}",
+        rust.lines().filter(|l| l.contains("acc")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        !rust.contains("let mut acc = Value::Number"),
+        "acc must NOT be boxed:\n{}",
+        rust.lines().filter(|l| l.contains("acc")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    // The per-iteration accumulator update is native arithmetic, not boxed ops on `acc`.
+    assert!(
+        !rust.contains("ops::mul(&acc"),
+        "acc update must be native f64, not a boxed ops::mul on acc"
+    );
+}
+
+#[test]
+fn issue_169_non_number_array_reduce_does_not_make_accumulator_native() {
+    // Conservative bail: reduce over a *string* array is not a native f64 fold, so an accumulator it
+    // feeds must stay boxed (sound — we never claim F64 where the emitter would box).
+    let src = r#"
+let ss: string[] = ["a", "b", "c"]
+let acc: number = 0
+let r: number = 0
+while (r < 10) {
+  acc = acc + ss.length
+  r = r + 1
+}
+console.log(acc)
+"#;
+    // Just assert it compiles and is sound; `acc` here is fed by `.length` which is a separate lever.
+    let rust = compile_typed(src);
+    assert!(rust.contains("fn main"), "compiles to a native program");
+}
+
+// ── #173: fill-loop fusion + native `.length` ─────────────────────────────────────────────────
+
+#[test]
+fn issue_173_fill_loop_fuses_to_bulk_extend() {
+    // `let a = []; for (let i = 0; i < N; i++) { a.push(K) }` over a native Vec lowers to a single
+    // `a.extend(std::iter::repeat(K).take((N) as usize))` — one allocation, no per-element pushes.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    // boolean[] fill with a literal bound.
+    assert!(
+        rust.contains("extend(std::iter::repeat(true).take((8_f64) as usize))"),
+        "boolean fill loop must fuse to a bulk extend:\n{}",
+        rust.lines().filter(|l| l.contains("repeat")).collect::<Vec<_>>().join("\n")
+    );
+    // number[] fill with an integer-`let` bound (`n`).
+    assert!(
+        rust.contains("extend(std::iter::repeat(1_f64).take((n) as usize))"),
+        "number fill loop with an int-range bound must fuse:\n{}",
+        rust.lines().filter(|l| l.contains("repeat")).collect::<Vec<_>>().join("\n")
+    );
+}
+
+#[test]
+fn issue_173_length_is_native_f64() {
+    // `vec.length` on a native Vec lowers to `(vec.len() as f64)`, not a boxed `get_prop`.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    assert!(
+        rust.contains("a.len() as f64"),
+        "native Vec `.length` must lower to `(a.len() as f64)`"
+    );
+    assert!(
+        !rust.contains("get_prop(&a, \"length\")"),
+        "native Vec `.length` must not go through boxed get_prop"
+    );
+}
+
+#[test]
+fn issue_173_adversarial_cases_do_not_fuse() {
+    // Non-constant push arg, extra statement, and `break` in the body must NOT fuse — they keep the
+    // per-element push loop (correctness over coverage). The fixture's only fusions are the three
+    // canonical fills (8, n, 3); a non-constant `push(i * 2)` must not produce an extend.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    assert!(
+        !rust.contains("repeat((i * 2"),
+        "non-constant push arg must not be fused into a repeat-fill"
+    );
+    // Exactly the three sound fills are emitted (8, n, 3) — no extra fusions crept in.
+    let fusions = rust.matches("std::iter::repeat").count();
+    assert_eq!(
+        fusions, 3,
+        "exactly 3 fill loops should fuse (boolFill=8, sieve=n, oobGrow=3), found {fusions}"
+    );
+}

package/crates/tish_compile_js/src/codegen.rs

@@ -20,11 +20,23 @@ enum EmitMode {
     Esm,
 }
 
+/// How ESM import specifiers are rewritten. `Disk` (production `--format esm`) rewrites `.tish`
+/// specifiers to their sibling `.js` output paths and resolves bare specifiers to relative paths
+/// into the emitted module tree. `ViteDev` keeps relative `.tish` specifiers and bare specifiers
+/// as-is so Vite's `resolveId`/`load` re-enters the plugin per module (in-graph HMR, issue #284).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ImportRewrite {
+    Disk,
+    ViteDev,
+}
+
 struct Codegen {
     output: String,
     indent: usize,
     in_async: bool,
     emit_mode: EmitMode,
+    /// ESM only: how import specifiers are rewritten (disk `.js` paths vs Vite-dev `.tish`).
+    import_rewrite: ImportRewrite,
     /// ESM only: the absolute path of the module being emitted (the importer), used to rewrite
     /// relative/bare import specifiers to sibling `.js` output paths.
     module_path: PathBuf,
@@ -48,17 +60,19 @@ impl Codegen {
             indent: 0,
             in_async: false,
             emit_mode: EmitMode::Bundle,
+            import_rewrite: ImportRewrite::Disk,
             module_path: PathBuf::new(),
             project_root: PathBuf::new(),
         }
     }
 
-    fn new_esm(module_path: PathBuf, project_root: PathBuf) -> Self {
+    fn new_esm(module_path: PathBuf, project_root: PathBuf, import_rewrite: ImportRewrite) -> Self {
         Self {
             output: String::new(),
             indent: 0,
             in_async: false,
             emit_mode: EmitMode::Esm,
+            import_rewrite,
             module_path,
             project_root,
         }
@@ -907,7 +921,12 @@ impl Codegen {
         specifiers: &[ImportSpecifier],
         from: &str,
     ) -> Result<(), CompileError> {
-        let spec = rewrite_import_to_js(from, &self.module_path, &self.project_root)?;
+        let spec = rewrite_import_to_js(
+            from,
+            &self.module_path,
+            &self.project_root,
+            self.import_rewrite,
+        )?;
         let mut named: Vec<String> = Vec::new();
         let mut default_local: Option<String> = None;
         let mut namespace_local: Option<String> = None;
@@ -987,6 +1006,7 @@ fn rewrite_import_to_js(
     spec: &str,
     importer_abs: &Path,
     project_root: &Path,
+    rewrite: ImportRewrite,
 ) -> Result<String, CompileError> {
     if tishlang_compile::is_native_import(spec) {
         return Err(CompileError {
@@ -996,6 +1016,11 @@ fn rewrite_import_to_js(
             ),
         });
     }
+    // Vite dev keeps specifiers verbatim: relative `.tish` paths and bare packages are left for the
+    // plugin's `resolveId`/`load` (relative) or Node/Vite resolution (bare) to handle per-module.
+    if rewrite == ImportRewrite::ViteDev {
+        return Ok(spec.to_string());
+    }
     if spec.starts_with("./") || spec.starts_with("../") {
         return Ok(spec_ext_to_js(spec));
     }
@@ -1249,7 +1274,8 @@ pub fn compile_project_esm(
         } else {
             module.program.clone()
         };
-        let mut gen = Codegen::new_esm(mod_canon.clone(), res_root_canon.clone());
+        let mut gen =
+            Codegen::new_esm(mod_canon.clone(), res_root_canon.clone(), ImportRewrite::Disk);
         gen.emit_program(&program, None, None)?;
         out.push(EmittedJsModule {
             relative_path: rel_js,
@@ -1259,6 +1285,84 @@ pub fn compile_project_esm(
     Ok(out)
 }
 
+/// Compile a **single** `.tish` module to one ES module (issue #284, Vite dev / HMR). Unlike
+/// [`compile_project_esm`], the dependency graph is **not** resolved — only `module_path` is read
+/// and parsed — so a Vite plugin can compile one file per `load()` and let Vite own the module
+/// graph. With `ImportRewrite::ViteDev` relative `.tish` specifiers and bare packages are preserved
+/// so Vite re-enters the plugin per dependency. When `source_map` is set, a v3 map back to the
+/// `.tish` source is returned (requires `optimize == false`, matching the bundle source-map rule).
+pub fn compile_module_esm(
+    module_path: &Path,
+    project_root: Option<&Path>,
+    optimize: bool,
+    import_rewrite: ImportRewrite,
+    source_map: bool,
+) -> Result<JsBundle, CompileError> {
+    if source_map && optimize {
+        return Err(CompileError {
+            message: "source map requires no optimization (mappings follow unmerged statement order)."
+                .into(),
+        });
+    }
+    let source = std::fs::read_to_string(module_path).map_err(|e| CompileError {
+        message: format!("Cannot read {}: {}", module_path.display(), e),
+    })?;
+    let parsed = tishlang_parser::parse(&source).map_err(|e| CompileError {
+        message: format!("Parse error in {}: {}", module_path.display(), e),
+    })?;
+    let program = if optimize {
+        tishlang_opt::optimize(&parsed)
+    } else {
+        parsed
+    };
+    let module_canon = module_path
+        .canonicalize()
+        .unwrap_or_else(|_| module_path.to_path_buf());
+    let root = project_root
+        .map(Path::to_path_buf)
+        .or_else(|| module_path.parent().map(Path::to_path_buf))
+        .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);
+    if source_map {
+        let stmt_sources = vec![module_canon.clone(); program.statements.len()];
+        let mut builder = SourceMapBuilder::new(Some("module.js"));
+        builder.set_source_root(Some(""));
+        gen.emit_program(
+            &program,
+            Some((stmt_sources.as_slice(), root_canon.as_path())),
+            Some(&mut builder),
+        )?;
+        let mut sm = builder.into_sourcemap();
+        // Embed the original `.tish` so consumers (Vite, browser devtools) never resolve
+        // `sources` from disk. The map's `sources` are project-root-relative, but Vite resolves
+        // them against the module's own directory; without inline content it logs
+        // "Sourcemap ... points to missing source files" and devtools can't show the original.
+        let source_count = sm.get_source_count();
+        for id in 0..source_count {
+            sm.set_source_contents(id, Some(&source));
+        }
+        let mut v = Vec::new();
+        sm.to_writer(&mut v).map_err(|e| CompileError {
+            message: e.to_string(),
+        })?;
+        let map_json = String::from_utf8(v).map_err(|e| CompileError {
+            message: e.to_string(),
+        })?;
+        Ok(JsBundle {
+            js: gen.output,
+            source_map_json: Some(map_json),
+        })
+    } else {
+        gen.emit_program(&program, None, None)?;
+        Ok(JsBundle {
+            js: gen.output,
+            source_map_json: None,
+        })
+    }
+}
+
 /// Deepest directory that is an ancestor of every given file path, compared component-wise. Used as
 /// the base of the `--format esm` output tree so modules outside the entry's project root (sibling
 /// packages, `node_modules`) still map to a stable, collision-free location. For a single file this

package/crates/tish_compile_js/src/lib.rs

@@ -8,8 +8,9 @@ mod error;
 mod tests_jsx;
 
 pub use codegen::{
-    compile_project_esm, compile_project_with_jsx, compile_project_with_jsx_and_source_map,
-    compile_with_jsx, EmittedJsModule, JsBundle,
+    compile_module_esm, compile_project_esm, compile_project_with_jsx,
+    compile_project_with_jsx_and_source_map, compile_with_jsx, EmittedJsModule, ImportRewrite,
+    JsBundle,
 };
 pub use error::CompileError;
 

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -4,7 +4,10 @@ mod tests {
 
     use tishlang_parser::parse;
 
-    use crate::{compile_project_esm, compile_project_with_jsx, compile_with_jsx, EmittedJsModule};
+    use crate::{
+        compile_module_esm, compile_project_esm, compile_project_with_jsx, compile_with_jsx,
+        EmittedJsModule, ImportRewrite,
+    };
 
     #[test]
     fn lattish_jsx_emits_h_with_children_array() {
@@ -639,4 +642,170 @@ fn factory() {
             err.message
         );
     }
+
+    // ── #284: single-module compile for Vite dev (in-graph HMR) ───────────────────────────────
+
+    /// Write `modules` into a fresh temp dir and compile just `entry` (no graph resolution),
+    /// in Vite-dev import-rewrite mode without a source map.
+    fn build_module_vite(entry: &str, modules: &[(&str, &str)]) -> String {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        for (rel, src) in modules {
+            let p = dir.join(rel);
+            if let Some(parent) = p.parent() {
+                std::fs::create_dir_all(parent).unwrap();
+            }
+            let mut f = std::fs::File::create(&p).unwrap();
+            f.write_all(src.as_bytes()).unwrap();
+            f.sync_all().unwrap();
+        }
+        compile_module_esm(
+            &dir.join(entry),
+            Some(dir),
+            false,
+            ImportRewrite::ViteDev,
+            false,
+        )
+        .expect("compile_module_esm failed")
+        .js
+    }
+
+    #[test]
+    fn compile_module_esm_vite_preserves_relative_tish_imports() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { id } from \"./dep.tish\"\nconsole.log(id(1))\n",
+            )],
+        );
+        assert!(
+            js.contains("import { id } from \"./dep.tish\";"),
+            "Vite dev keeps the .tish specifier so resolveId re-enters the plugin:\n{js}"
+        );
+        assert!(
+            !js.contains("./dep.js"),
+            "Vite dev must NOT rewrite .tish to .js:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_vite_leaves_bare_specifiers_unchanged() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { h } from \"lattish\"\nconsole.log(h)\n",
+            )],
+        );
+        assert!(
+            js.contains("import { h } from \"lattish\";"),
+            "bare specifier passes through for normal Node/Vite resolution:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_vite_emits_exports() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "export const VERSION = \"1.0\"\nexport fn greet(n) { return \"hi \" + n }\nexport default greet\n",
+            )],
+        );
+        assert!(js.contains("export const VERSION = \"1.0\";"), "named const export:\n{js}");
+        assert!(js.contains("export function greet "), "named fn export:\n{js}");
+        assert!(js.contains("export default greet;"), "default export:\n{js}");
+    }
+
+    #[test]
+    fn compile_module_esm_does_not_resolve_graph() {
+        // Compiling a single module must not read or require its dependencies to exist on disk:
+        // only the entry file is created, yet the import to a missing `./dep.tish` compiles fine.
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { id } from \"./dep.tish\"\nconsole.log(id(1))\n",
+            )],
+        );
+        assert!(
+            js.contains("import { id } from \"./dep.tish\";"),
+            "single-module compile emits the import without loading the dependency:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_rejects_native_imports() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        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)
+            .unwrap_err();
+        assert!(
+            err.message.contains("Native module import"),
+            "expected a native-import rejection, got: {}",
+            err.message
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_maps_statement_to_tish_file() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        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();
+        let map = bundle
+            .source_map_json
+            .expect("source map requested → must be present");
+        assert!(
+            map.contains("\"version\":3") || map.contains("\"version\": 3"),
+            "v3 source map:\n{map}"
+        );
+        assert!(
+            map.contains("main.tish"),
+            "map sources reference the .tish file:\n{map}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_embeds_sources_content() {
+        // The map must carry sourcesContent so Vite/devtools never resolve `sources` from disk
+        // (otherwise Vite warns "Sourcemap ... points to missing source files").
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        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();
+        let map = bundle.source_map_json.expect("source map requested");
+        assert!(
+            map.contains("\"sourcesContent\""),
+            "map must include a sourcesContent field:\n{map}"
+        );
+        assert!(
+            map.contains("export fn greet"),
+            "sourcesContent must embed the original .tish source:\n{map}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_requires_no_optimize() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        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)
+            .unwrap_err();
+        assert!(
+            err.message.to_lowercase().contains("optimiz"),
+            "source map + optimize must be rejected, got: {}",
+            err.message
+        );
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "2.9.0",
+  "version": "2.10.1",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {