@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish/tests/integration_test.rs

@@ -0,0 +1,1406 @@
+//! Full-stack integration tests: run .tish files with interpreter or each backend and compare
+//! stdout to static expected files (e.g. `fn_any.tish.expected`).
+//!
+//! - Run: `cargo test -p tishlang` (or `cargo nextest run -p tishlang`).
+//! - Generate/update expected files: `REGENERATE_EXPECTED=1 cargo test -p tishlangtest_mvp_programs_interpreter`
+//!   then commit the new/updated `tests/core/*.tish.expected` files.
+//! - Compiled outputs are cached under `target/integration_compile_cache/` per backend.
+//!   MVP native tests use `native_many/<hash>/` plus one batched nested Cargo build.
+
+use std::collections::hash_map::DefaultHasher;
+use std::ffi::OsString;
+use std::hash::{Hash, Hasher};
+use std::io::Read;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use rayon::prelude::*;
+use tishlang_native::compile_many_to_native;
+
+fn workspace_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("..")
+        .join("..")
+}
+
+fn core_dir() -> PathBuf {
+    workspace_root().join("tests").join("core")
+}
+
+/// Path to the static expected stdout for a .tish file (e.g. fn_any.tish -> fn_any.tish.expected).
+fn expected_path(path: &Path) -> PathBuf {
+    path.with_file_name(format!(
+        "{}.expected",
+        path.file_name().unwrap().to_string_lossy()
+    ))
+}
+
+/// Read static expected stdout for a test file. Returns None if the file does not exist.
+fn get_expected(path: &Path) -> Option<String> {
+    let p = expected_path(path);
+    std::fs::read_to_string(&p).ok()
+}
+
+fn target_dir() -> PathBuf {
+    std::env::var("CARGO_TARGET_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| workspace_root().join("target"))
+}
+
+/// Cache dir for tish build outputs (under target/ so CI rust-cache restores it).
+fn integration_compile_cache_dir() -> PathBuf {
+    target_dir().join("integration_compile_cache")
+}
+
+/// Match `tish build` with no `--feature`: link every capability compiled into this `tish` binary.
+fn native_build_features_for_integration_test() -> Vec<String> {
+    let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
+        .into_iter()
+        .collect();
+    v.sort();
+    v
+}
+
+fn combined_mvp_native_inputs_hash(paths: &[PathBuf]) -> u64 {
+    let mut h = DefaultHasher::new();
+    let feats = native_build_features_for_integration_test();
+    feats.len().hash(&mut h);
+    for f in &feats {
+        f.hash(&mut h);
+    }
+    paths.len().hash(&mut h);
+    for p in paths {
+        p.file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .hash(&mut h);
+        file_content_hash(p).hash(&mut h);
+    }
+    // Native batch cache must invalidate when the emitter or `value_call` changes — not only
+    // when `.tish` sources change; otherwise CI/rust-cache can keep stale nested binaries.
+    let codegen_rs = workspace_root().join("crates/tish_compile/src/codegen.rs");
+    if codegen_rs.is_file() {
+        file_content_hash(&codegen_rs).hash(&mut h);
+    }
+    let value_rs = workspace_root().join("crates/tish_core/src/value.rs");
+    if value_rs.is_file() {
+        file_content_hash(&value_rs).hash(&mut h);
+    }
+    // Inference (struct/param/return typing — M1/M4/M5) also drives native emission, so the
+    // native batch cache must invalidate when it changes too.
+    let infer_rs = workspace_root().join("crates/tish_compile/src/infer.rs");
+    if infer_rs.is_file() {
+        file_content_hash(&infer_rs).hash(&mut h);
+    }
+    h.finish()
+}
+
+fn mvp_native_batch_cache_dir(combined: u64) -> PathBuf {
+    integration_compile_cache_dir()
+        .join("native_many")
+        .join(format!("{:016x}", combined))
+}
+
+/// Restores the previous process env when dropped (for `TISH_FAST_NATIVE_BUILD` in batch tests).
+struct EnvVarGuard {
+    key: &'static str,
+    previous: Option<std::ffi::OsString>,
+}
+
+impl EnvVarGuard {
+    fn set(key: &'static str, value: &str) -> Self {
+        let previous = std::env::var_os(key);
+        std::env::set_var(key, value);
+        Self { key, previous }
+    }
+}
+
+impl Drop for EnvVarGuard {
+    fn drop(&mut self) {
+        match &self.previous {
+            None => std::env::remove_var(self.key),
+            Some(v) => std::env::set_var(self.key, v),
+        }
+    }
+}
+
+fn file_content_hash(path: &Path) -> u64 {
+    let mut f = std::fs::File::open(path).expect("open file for hash");
+    let mut content = Vec::new();
+    f.read_to_end(&mut content).expect("read file for hash");
+    let mut h = DefaultHasher::new();
+    path.to_string_lossy().hash(&mut h);
+    content.hash(&mut h);
+    h.finish()
+}
+
+/// Compile a .tish file with the given backend, using a persistent cache so we only run
+/// `tish build` when the file or backend changed. Returns path to the compiled artifact
+/// (binary, .js, or .wasm) in a temp dir; caller may run it and then delete it.
+///
+/// Cache is keyed by backend (native, cranelift, js, wasi) so e.g. cranelift and wasi
+/// compiles of the same file do not overwrite each other: .../cranelift/<stem>_<hash> vs .../wasi/<stem>_<hash>.wasm.
+///
+/// The artifact **basename** must be unique per `(stem, hash, backend)`: nested `tish build`
+/// uses it as the Cargo binary name under the workspace `target/release/`. If native and
+/// cranelift both used `strict_equality_<hash>`, parallel `cargo nextest` could run those
+/// tests concurrently and corrupt the same `target/release/...` output (Linux: ETXTBSY when
+/// executing a binary still being written).
+fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
+    let stem = path.file_stem().unwrap().to_string_lossy();
+    // The cache must invalidate when the COMPILER changes, not only the `.tish` source: cranelift/wasi
+    // (and native) bake the VM/codegen/runtime into the artifact, so a stale cached binary built before
+    // a VM fix would silently use old behaviour. The `tish` binary's mtime is the precise signal — any
+    // VM/compiler/runtime/codegen source edit rebuilds it. Mix it into the key alongside the file hash.
+    let bin_stamp = std::fs::metadata(bin)
+        .and_then(|m| m.modified())
+        .ok()
+        .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+        .map(|d| d.as_nanos() as u64)
+        .unwrap_or(0);
+    let hash = {
+        let mut h = DefaultHasher::new();
+        file_content_hash(path).hash(&mut h);
+        bin_stamp.hash(&mut h);
+        h.finish()
+    };
+    let hash8 = &format!("{:016x}", hash)[..8];
+    let cache_base = integration_compile_cache_dir().join(backend);
+    let _ = std::fs::create_dir_all(&cache_base);
+    // Include `backend` in the leaf name so nested cargo bin names never collide across backends.
+    let leaf = format!("{}__{}__{}", stem, backend, hash8);
+
+    let (artifact_path, compile_args): (PathBuf, Vec<OsString>) = match backend {
+        "native" => {
+            let ext = if cfg!(target_os = "windows") {
+                ".exe"
+            } else {
+                ""
+            };
+            let cached = cache_base.join(format!("{}{}", leaf, ext));
+            let args = vec![
+                OsString::from("build"),
+                OsString::from(path),
+                OsString::from("-o"),
+                OsString::from(&cached),
+            ];
+            (cached, args)
+        }
+        "cranelift" => {
+            let ext = if cfg!(target_os = "windows") {
+                ".exe"
+            } else {
+                ""
+            };
+            let cached = cache_base.join(format!("{}{}", leaf, ext));
+            let args = vec![
+                OsString::from("build"),
+                OsString::from(path),
+                OsString::from("-o"),
+                OsString::from(&cached),
+                OsString::from("--native-backend"),
+                OsString::from("cranelift"),
+            ];
+            (cached, args)
+        }
+        "js" => {
+            let cached = cache_base.join(format!("{}.js", leaf));
+            let args = vec![
+                OsString::from("build"),
+                OsString::from(path),
+                OsString::from("--target"),
+                OsString::from("js"),
+                OsString::from("-o"),
+                OsString::from(&cached),
+            ];
+            (cached, args)
+        }
+        "wasi" => {
+            let out_base = cache_base.join(&leaf);
+            let artifact = out_base.with_extension("wasm");
+            let args = vec![
+                OsString::from("build"),
+                OsString::from(path),
+                OsString::from("-o"),
+                OsString::from(&out_base),
+                OsString::from("--target"),
+                OsString::from("wasi"),
+            ];
+            (artifact, args)
+        }
+        _ => panic!("unknown backend {}", backend),
+    };
+
+    if !artifact_path.exists() {
+        let out = Command::new(bin)
+            .args(compile_args)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish build");
+        assert!(
+            out.status.success(),
+            "Compile failed for {} ({}): {}",
+            path.display(),
+            backend,
+            String::from_utf8_lossy(&out.stderr)
+        );
+    }
+
+    // Copy to temp so caller can run and delete without touching cache.
+    let ext = artifact_path
+        .extension()
+        .map(|e| e.to_string_lossy().to_string())
+        .unwrap_or_default();
+    let temp_dest =
+        std::env::temp_dir().join(format!("tish_cached_{}_{}_{}", backend, stem, hash8));
+    let temp_dest = if ext.is_empty() {
+        temp_dest
+    } else {
+        temp_dest.with_extension(ext)
+    };
+    std::fs::copy(&artifact_path, &temp_dest).expect("copy cached artifact to temp");
+    temp_dest
+}
+
+/// Path to the tish CLI binary. When running under cargo-llvm-cov, the build goes to
+/// target/llvm-cov-target and CARGO_TARGET_DIR may not be set for the test process.
+fn tish_bin() -> PathBuf {
+    let bin_name = if cfg!(target_os = "windows") {
+        "tish.exe"
+    } else {
+        "tish"
+    };
+    let default = target_dir().join("debug").join(bin_name);
+    if default.exists() {
+        return default;
+    }
+    let llvm_cov = workspace_root()
+        .join("target")
+        .join("llvm-cov-target")
+        .join("debug")
+        .join(bin_name);
+    if llvm_cov.exists() {
+        return llvm_cov;
+    }
+    default
+}
+
+/// tish -V and --version print the version.
+#[test]
+fn test_tish_version_flag() {
+    let bin = tish_bin();
+    assert!(
+        bin.exists(),
+        "tish binary not found. Run `cargo build -p tishlang` first."
+    );
+    let out = Command::new(&bin).arg("-V").output().expect("run tish -V");
+    assert!(
+        out.status.success(),
+        "tish -V failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains(env!("CARGO_PKG_VERSION")),
+        "tish -V should print version {}; got: {}",
+        env!("CARGO_PKG_VERSION"),
+        stdout
+    );
+    let out2 = Command::new(&bin)
+        .arg("--version")
+        .output()
+        .expect("run tish --version");
+    assert!(out2.status.success());
+    let stdout2 = String::from_utf8_lossy(&out2.stdout);
+    assert!(
+        stdout2.contains(env!("CARGO_PKG_VERSION")),
+        "tish --version should print version"
+    );
+}
+
+/// Parse async-await example (validates async fn parsing).
+#[test]
+fn test_async_await_parse() {
+    let path = workspace_root()
+        .join("examples")
+        .join("async-await")
+        .join("src")
+        .join("main.tish");
+    if path.exists() {
+        let source = std::fs::read_to_string(&path).unwrap();
+        let result = tishlang_parser::parse(&source);
+        assert!(
+            result.is_ok(),
+            "Parse failed for {}: {:?}",
+            path.display(),
+            result.err()
+        );
+    }
+}
+
+/// Invoke tish binary to compile async-await and run compiled output (validates non-blocking pipeline).
+#[test]
+#[cfg(feature = "http")]
+fn test_async_await_compile_via_binary() {
+    let bin = tish_bin();
+    let path = workspace_root()
+        .join("examples")
+        .join("async-await")
+        .join("src")
+        .join("main.tish");
+    if path.exists() && bin.exists() {
+        let out = std::env::temp_dir().join("tish_async_test_out");
+        let compile_result = Command::new(&bin)
+            .args([
+                "build",
+                path.to_string_lossy().as_ref(),
+                "-o",
+                out.to_string_lossy().as_ref(),
+            ])
+            .current_dir(workspace_root())
+            .output();
+        let compile_out = compile_result.expect("run tish build");
+        assert!(
+            compile_out.status.success(),
+            "tish build failed: {}",
+            String::from_utf8_lossy(&compile_out.stderr)
+        );
+        // Run compiled binary to validate non-blocking fetchAll executes correctly
+        let run_result = Command::new(&out).current_dir(workspace_root()).output();
+        let run_out = run_result.expect("run compiled async binary");
+        assert!(
+            run_out.status.success(),
+            "compiled async binary failed: {}",
+            String::from_utf8_lossy(&run_out.stderr)
+        );
+        let stdout = String::from_utf8_lossy(&run_out.stdout);
+        assert!(
+            stdout.contains("Fetching"),
+            "expected output to mention fetching"
+        );
+        assert!(stdout.contains("Done"), "expected output to contain Done");
+    }
+}
+
+/// DEFINITIVE VALIDATION: Parallel fetches must be faster than sequential.
+/// Uses httpbin.org/delay/1 (1s each). 3 parallel ≈ 1s, 3 sequential ≈ 3s.
+#[test]
+#[cfg(feature = "http")]
+#[ignore = "timing and network sensitive; run manually: cargo test test_async_parallel_vs_sequential_timing -p tishlang--features http -- --ignored"]
+fn test_async_parallel_vs_sequential_timing() {
+    let bin = tish_bin();
+    let parallel_src = workspace_root()
+        .join("examples")
+        .join("async-await")
+        .join("src")
+        .join("parallel.tish");
+    let sequential_src = workspace_root()
+        .join("examples")
+        .join("async-await")
+        .join("src")
+        .join("sequential.tish");
+    if !parallel_src.exists() || !sequential_src.exists() || !bin.exists() {
+        return;
+    }
+    let out_parallel = std::env::temp_dir().join("tish_parallel_timing");
+    let out_sequential = std::env::temp_dir().join("tish_sequential_timing");
+
+    // Compile both
+    let compile_par = Command::new(&bin)
+        .args([
+            "build",
+            parallel_src.to_string_lossy().as_ref(),
+            "-o",
+            out_parallel.to_string_lossy().as_ref(),
+        ])
+        .current_dir(workspace_root())
+        .output();
+    assert!(
+        compile_par.as_ref().unwrap().status.success(),
+        "compile parallel: {}",
+        String::from_utf8_lossy(&compile_par.as_ref().unwrap().stderr)
+    );
+
+    let compile_seq = Command::new(&bin)
+        .args([
+            "build",
+            sequential_src.to_string_lossy().as_ref(),
+            "-o",
+            out_sequential.to_string_lossy().as_ref(),
+        ])
+        .current_dir(workspace_root())
+        .output();
+    assert!(
+        compile_seq.as_ref().unwrap().status.success(),
+        "compile sequential: {}",
+        String::from_utf8_lossy(&compile_seq.as_ref().unwrap().stderr)
+    );
+
+    // Run parallel and time
+    let t_parallel = std::time::Instant::now();
+    let run_par = Command::new(&out_parallel)
+        .current_dir(workspace_root())
+        .output();
+    let elapsed_parallel = t_parallel.elapsed();
+    assert!(
+        run_par.as_ref().unwrap().status.success(),
+        "run parallel: {}",
+        String::from_utf8_lossy(&run_par.as_ref().unwrap().stderr)
+    );
+
+    // Run sequential and time
+    let t_sequential = std::time::Instant::now();
+    let run_seq = Command::new(&out_sequential)
+        .current_dir(workspace_root())
+        .output();
+    let elapsed_sequential = t_sequential.elapsed();
+    assert!(
+        run_seq.as_ref().unwrap().status.success(),
+        "run sequential: {}",
+        String::from_utf8_lossy(&run_seq.as_ref().unwrap().stderr)
+    );
+
+    // PARALLEL MUST BE FASTER: parallel < sequential * 0.6 (parallel ~1s, sequential ~3s)
+    let parallel_secs = elapsed_parallel.as_secs_f64();
+    let sequential_secs = elapsed_sequential.as_secs_f64();
+    assert!(
+        parallel_secs < sequential_secs * 0.6,
+        "Async NOT validated: parallel took {:.2}s but sequential took {:.2}s. Parallel must be < 60% of sequential to prove non-blocking.",
+        parallel_secs,
+        sequential_secs
+    );
+}
+
+/// Run async-await example via tishlang_eval (same path as `tish run`).
+/// Ignored: tishlang_eval::run() is synchronous and does not run the event loop.
+#[test]
+#[cfg(feature = "http")]
+#[ignore = "requires async runtime; use test_async_await_compile_via_binary for CI"]
+fn test_async_await_run() {
+    let path = workspace_root()
+        .join("examples")
+        .join("async-await")
+        .join("src")
+        .join("main.tish");
+    if path.exists() {
+        let source = std::fs::read_to_string(&path).unwrap();
+        let result = tishlang_eval::run(&source);
+        assert!(
+            result.is_ok(),
+            "Run failed for {}: {:?}",
+            path.display(),
+            result.err()
+        );
+    }
+}
+
+/// `promise.tish` — full Promise API including `new Promise(executor)`, `.then`, `.catch`,
+/// `all`, `race`, `any`, `allSettled`. Runs via the binary (vm + interp), asserts exact output.
+/// This was previously `#[ignore]`'d and only checked "doesn't error" — the old fixture also
+/// avoided `new Promise` entirely, hiding a bug where the executor never ran on the VM. Now
+/// CI-gated and output-asserting. vm ≡ interp.
+#[test]
+fn test_promise_core() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let path = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("promise.tish");
+    if !path.exists() {
+        return;
+    }
+    let expected = "\
+new Promise: new-ctor
+Promise sync resolve: 42
+Promise.resolve: 100
+Promise.reject caught: true
+.then chain: 4
+.catch: handled: fail
+Promise.all: 1 2 3
+Promise.race: fast
+Promise.any: any-win
+Promise.allSettled: fulfilled rejected reason
+Promise tests completed
+";
+    for backend_args in [vec!["run"], vec!["run", "--backend", "interp"]] {
+        let mut args = backend_args.clone();
+        args.push(path.to_string_lossy().to_string().leak());
+        let out = Command::new(&bin)
+            .args(&args)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish binary");
+        assert!(
+            out.status.success(),
+            "promise.tish ({:?}) failed: stderr={}",
+            backend_args,
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "Promise output mismatch on backend {:?} — check new Promise/any/allSettled regressions",
+            backend_args
+        );
+    }
+}
+
+/// Import aliasing — `{ x as y }` rename and `* as M` namespace. `as` is a dedicated keyword
+/// token (shared with type casts), so the import-specifier parser must accept it in that position.
+/// Regression: previously `import { a as b }` failed with "Expected Comma, got As". vm ≡ interp.
+#[test]
+fn test_import_alias() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let path = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("import_alias.tish");
+    if !path.exists() {
+        return;
+    }
+    let expected = "42\nhi there\n42\n1.0\n";
+    for backend_args in [vec!["run"], vec!["run", "--backend", "vm"]] {
+        let mut args = backend_args.clone();
+        args.push(path.to_string_lossy().to_string().leak());
+        let out = Command::new(&bin)
+            .args(&args)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish binary");
+        assert!(
+            out.status.success(),
+            "import_alias.tish ({:?}) failed: stderr={}",
+            backend_args,
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "import alias output mismatch on backend {:?}",
+            backend_args
+        );
+    }
+}
+
+/// Combined validation: async/await + Promise + setTimeout + multiple HTTP requests.
+/// #97: a module's non-exported top-level bindings stay private — a same-named binding in
+/// another module must not overwrite them (runtime), and the `--target js` bundle must not
+/// emit duplicate `let` declarations (SyntaxError). Verified identical across interp / VM /
+/// native / node, including parameter and inner-`let` shadowing.
+#[test]
+fn test_module_private_binding_isolation() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let path = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("private_isolation.tish");
+    if !path.exists() {
+        return;
+    }
+    let expected = "from-a:helper-a from-b:helper-b\narg inner\nhelper-b\n";
+
+    // Interpreter + VM via `tish run`.
+    for backend in ["interp", "vm"] {
+        let out = Command::new(&bin)
+            .args(["run", "--backend", backend])
+            .arg(&path)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish binary");
+        assert!(
+            out.status.success(),
+            "private_isolation.tish ({backend}) failed: stderr={}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "module private-binding isolation mismatch on backend {backend}"
+        );
+    }
+
+    // Native: compile + run.
+    let native_bin = compile_cached(&bin, &path, "native");
+    let out = Command::new(&native_bin)
+        .current_dir(workspace_root())
+        .output()
+        .expect("run native binary");
+    let _ = std::fs::remove_file(&native_bin);
+    assert!(
+        out.status.success(),
+        "private_isolation native run failed: stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert_eq!(
+        String::from_utf8_lossy(&out.stdout),
+        expected,
+        "module private-binding isolation mismatch on native backend"
+    );
+
+    // JS target: compile + run through Node (also asserts no duplicate-`let` SyntaxError).
+    let node_available = Command::new("node")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if node_available {
+        let out_js = compile_cached(&bin, &path, "js");
+        let out = Command::new("node")
+            .arg(&out_js)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run node");
+        let _ = std::fs::remove_file(&out_js);
+        assert!(
+            out.status.success(),
+            "private_isolation JS run failed: stderr={}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "module private-binding isolation mismatch on JS target"
+        );
+    }
+}
+
+/// Ignored: tishlang_eval::run() does not run the event loop.
+#[test]
+#[cfg(feature = "http")]
+#[ignore = "requires async runtime"]
+fn test_async_promise_settimeout_combined() {
+    let path = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("async_promise_settimeout.tish");
+    if path.exists() {
+        let source = std::fs::read_to_string(&path).unwrap();
+        let result = tishlang_eval::run(&source);
+        assert!(
+            result.is_ok(),
+            "Failed to run async_promise_settimeout: {:?}",
+            result.err()
+        );
+    }
+}
+
+/// VM run with Date global (resolve+merge+bytecode+run pipeline).
+#[test]
+fn test_vm_date_now() {
+    let path = workspace_root()
+        .join("tests")
+        .join("core")
+        .join("date.tish");
+    if !path.exists() {
+        return;
+    }
+    // Library path
+    let modules = tishlang_compile::resolve_project(&path, path.parent()).expect("resolve");
+    tishlang_compile::detect_cycles(&modules).expect("cycles");
+    let program = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
+    let chunk = tishlang_bytecode::compile(&program).expect("compile");
+    let result = tishlang_vm::run(&chunk);
+    assert!(
+        result.is_ok(),
+        "VM run (library) failed: {:?}",
+        result.err()
+    );
+    // Binary path - same flow as `tish run <file>`
+    let bin = tish_bin();
+    if bin.exists() {
+        let out = Command::new(&bin)
+            .args(["run", path.to_string_lossy().as_ref()])
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish binary");
+        assert!(
+            out.status.success(),
+            "tish run failed: stdout={} stderr={}",
+            String::from_utf8_lossy(&out.stdout),
+            String::from_utf8_lossy(&out.stderr)
+        );
+    }
+}
+
+/// `Promise.any`, `Promise.allSettled`, fixed `Promise.race` — cross-backend, network-free, CI-gated.
+/// vm ≡ interp exact match.
+#[test]
+fn test_promise_combinators() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let path = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("promise_combinators.tish");
+    if !path.exists() {
+        return;
+    }
+    let expected = "\
+any first-fulfilled: win
+any all-rejected: [\"e1\",\"e2\"]
+allSettled[0] ok: 10
+allSettled[1] rejected: boom
+allSettled[2] ok: 30
+race winner: A
+any passthrough: 42
+";
+    for backend_args in [vec!["run"], vec!["run", "--backend", "interp"]] {
+        let mut args = backend_args.clone();
+        args.push(path.to_string_lossy().to_string().leak());
+        let out = Command::new(&bin)
+            .args(&args)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish binary");
+        assert!(
+            out.status.success(),
+            "promise_combinators ({:?}) failed: stderr={}",
+            backend_args,
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "Promise.any/allSettled/race divergence on backend {:?}",
+            backend_args
+        );
+    }
+}
+
+/// Pins tish's DOCUMENTED async/Promise ordering (docs/concurrency-model.md) — network-free, so it
+/// runs in CI (unlike the `#[ignore]`'d network async tests). Asserts Promise.all order + non-promise
+/// passthrough, `.then` chaining, await-reject catch, Promise.all reject short-circuit, AND the
+/// deliberate blocking signature: a 0ms `setTimeout` queued before an `await` fires LAST (a JS event
+/// loop would interleave it earlier — tish's `await` blocks instead of yielding). NOT compared to node
+/// on purpose; this is tish's own contract. vm ≡ interp guards cross-backend agreement.
+#[test]
+fn test_async_ordering_documented() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let path = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("async_ordering.tish");
+    if !path.exists() {
+        return;
+    }
+    // tish's documented, deliberately-non-JS ordering (timer drains last because await blocks).
+    let expected = "\
+1: sync-start
+2: await = 42
+2b: new Promise = ctor-ran
+3: all = a b c
+4: chain = 13
+5: caught = boom
+6: all-reject = rej
+7: post-await = after-timer-was-queued
+9: sync-end
+8: timer-fires-LAST (await did not yield)
+";
+    // Both the bytecode VM and the tree-walking interpreter must agree on this contract.
+    for backend_args in [vec!["run"], vec!["run", "--backend", "interp"]] {
+        let mut args = backend_args.clone();
+        args.push(path.to_string_lossy().to_string().leak());
+        let out = Command::new(&bin)
+            .args(&args)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish binary");
+        assert!(
+            out.status.success(),
+            "async_ordering ({:?}) failed: stderr={}",
+            backend_args,
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "async ordering divergence on backend {:?} — the documented blocking-await/timer contract changed",
+            backend_args
+        );
+    }
+}
+
+/// VM run with parse+compile only (no resolve/merge) - isolates bytecode IndexAssign.
+#[test]
+fn test_vm_index_assign_direct() {
+    let source = r#"let arr = [1, 2, 3]; arr[1] = 99; console.log(arr[1]);"#;
+    let program = tishlang_parser::parse(source).expect("parse");
+    let chunk = tishlang_bytecode::compile(&program).expect("compile");
+    let result = tishlang_vm::run(&chunk);
+    assert!(result.is_ok(), "VM IndexAssign failed: {:?}", result.err());
+}
+
+/// VM run via resolve+merge (same as tish run) - must also pass.
+#[test]
+fn test_vm_index_assign_via_resolve() {
+    let path = workspace_root()
+        .join("tests")
+        .join("core")
+        .join("array_sort_minimal.tish");
+    let modules = tishlang_compile::resolve_project(&path, path.parent()).expect("resolve");
+    tishlang_compile::detect_cycles(&modules).expect("cycles");
+    let program = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
+    let chunk = tishlang_bytecode::compile(&program).expect("compile");
+    let result = tishlang_vm::run(&chunk);
+    assert!(
+        result.is_ok(),
+        "VM IndexAssign via resolve failed: {:?}",
+        result.err()
+    );
+}
+
+/// tish run binary must pass array_sort_minimal (ensures CLI works).
+#[test]
+fn test_tish_run_index_assign() {
+    let bin = tish_bin();
+    let path = workspace_root()
+        .join("tests")
+        .join("core")
+        .join("array_sort_minimal.tish");
+    if !bin.exists() {
+        eprintln!("Skipping: tish binary not built");
+        return;
+    }
+    let out = Command::new(&bin)
+        .args(["run", path.to_string_lossy().as_ref()])
+        .current_dir(workspace_root())
+        .output()
+        .expect("run tish");
+    assert!(
+        out.status.success(),
+        "tish run failed: stdout={} stderr={}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        String::from_utf8_lossy(&out.stdout).contains("pass"),
+        "Expected 'pass' in output"
+    );
+}
+
+/// Full stack: lex + parse each .tish file and assert no parse error.
+#[test]
+fn test_full_stack_parse() {
+    let core_dir = core_dir();
+    for entry in std::fs::read_dir(&core_dir).unwrap() {
+        let path = entry.unwrap().path();
+        if path.extension().map(|e| e == "tish").unwrap_or(false) {
+            let source = std::fs::read_to_string(&path).unwrap();
+            let result = tishlang_parser::parse(&source);
+            assert!(
+                result.is_ok(),
+                "Parse failed for {}: {:?}",
+                path.display(),
+                result.err()
+            );
+        }
+    }
+}
+
+// (The hand-maintained `MVP_TEST_FILES` allowlist was removed in favor of `discover_core_tests()`
+// below — every `tests/core/*.tish` with a `.expected` now gets cross-backend coverage automatically.)
+
+/// Tests whose `.expected` embeds elapsed-ms timings (perf/stress/probe) — nondeterministic, so
+/// excluded from exact-output comparison. Run them via `just perf-*` instead.
+const TIMING_NONDETERMINISTIC: &[&str] = &[
+    "array_stress.tish",
+    "array_stress_01_large_array_creation.tish",
+    "array_stress_02_iteration.tish",
+    "array_stress_03_map_filter_reduce.tish",
+    "array_stress_04_chained.tish",
+    "array_stress_05_sorting.tish",
+    "array_stress_06_search.tish",
+    "array_stress_07_splice_slice.tish",
+    "array_stress_08_concat_spread.tish",
+    "array_stress_09_flat.tish",
+    "array_stress_10_objects.tish",
+    "basic_types.tish",
+    "benchmark_granular.tish",
+    "new_features_perf.tish",
+    "object_stress.tish",
+    "objects_perf.tish",
+    "string_methods_perf.tish",
+    "recursion_stress.tish",
+    "jit_probe.tish",
+];
+
+/// Known cross-backend gaps skipped on the interp↔vm parity check, with reason + a tracking note.
+/// Each is a real divergence to fix, not a permanent exclusion.
+///
+/// Empty: the former `nested_complex.tish` gap (the VM's fixed 2-level `enclosing` lost captures
+/// >2 levels deep — `level4` couldn't see `level1`'s `a`) is fixed. The VM now captures the full
+/// lexical chain (`Vm.enclosing: Vec<ScopeMap>`), so closures nested arbitrarily deep resolve
+/// every ancestor's locals. interp↔vm parity holds for all discovered tests.
+const VM_PARITY_SKIP: &[&str] = &[];
+
+/// Discover every `tests/core/*.tish` that has a `.expected` sibling, minus timing-nondeterministic
+/// ones. Replaces the hand-maintained `MVP_TEST_FILES` allowlist so a new `*.tish` + `*.expected`
+/// gets cross-backend coverage automatically (the allowlist silently left ~38 tests running nowhere).
+fn discover_core_tests() -> Vec<String> {
+    let mut v: Vec<String> = std::fs::read_dir(core_dir())
+        .expect("read tests/core")
+        .filter_map(|e| {
+            let p = e.ok()?.path();
+            if p.extension().map(|x| x == "tish").unwrap_or(false) && expected_path(&p).exists() {
+                Some(p.file_name()?.to_string_lossy().into_owned())
+            } else {
+                None
+            }
+        })
+        .filter(|n| !TIMING_NONDETERMINISTIC.contains(&n.as_str()))
+        .collect();
+    v.sort();
+    v
+}
+
+/// True if `name` has a sibling `.js` (so it can run through the Node oracle).
+fn has_js_sibling(name: &str) -> bool {
+    core_dir()
+        .join(name)
+        .with_extension("js")
+        .exists()
+}
+
+/// The gradual type checker must produce ZERO diagnostics on the (valid) corpus — any diagnostic is
+/// a false positive. Lists every offender so they can be inspected/fixed.
+#[test]
+fn checker_no_false_positives_on_corpus() {
+    let mut flagged: Vec<String> = Vec::new();
+    for name in discover_core_tests() {
+        let src = std::fs::read_to_string(core_dir().join(&name)).unwrap();
+        if let Ok(prog) = tishlang_parser::parse(&src) {
+            let diags = tishlang_compile::check_program(&prog);
+            if !diags.is_empty() {
+                let msgs: Vec<String> = diags.iter().map(|d| d.message.clone()).collect();
+                flagged.push(format!("{name}: {}", msgs.join(" | ")));
+            }
+        }
+    }
+    assert!(
+        flagged.is_empty(),
+        "type checker flagged valid corpus programs (false positives):\n{}",
+        flagged.join("\n")
+    );
+}
+
+/// Run each .tish file with interpreter and compare stdout to static expected.
+/// Set REGENERATE_EXPECTED=1 to write .expected files from interpreter output (run once, then commit).
+#[test]
+fn test_mvp_programs_interpreter() {
+    let core_dir = core_dir();
+    let bin = tish_bin();
+    assert!(
+        bin.exists(),
+        "tish binary not found at {}. Run `cargo build -p tishlang` first.",
+        bin.display()
+    );
+    let regenerate = std::env::var("REGENERATE_EXPECTED").as_deref() == Ok("1");
+    for name in &discover_core_tests() {
+        let path = core_dir.join(name);
+        if !path.exists() {
+            continue;
+        }
+        let path_str = path.to_string_lossy();
+        let out = Command::new(&bin)
+            .args(["run", path_str.as_ref(), "--backend", "interp"])
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish interpreter");
+        assert!(
+            out.status.success(),
+            "Interpreter failed for {}: {}",
+            path.display(),
+            String::from_utf8_lossy(&out.stderr)
+        );
+        let stdout = String::from_utf8_lossy(&out.stdout).to_string();
+        if regenerate {
+            std::fs::write(expected_path(&path), &stdout).expect("write expected");
+        } else {
+            let expected = get_expected(&path).unwrap_or_else(|| {
+                panic!(
+                    "missing expected file for {}; run with REGENERATE_EXPECTED=1 to generate",
+                    path.display()
+                )
+            });
+            assert_eq!(
+                stdout,
+                expected,
+                "Interpreter output mismatch for {}",
+                path.display()
+            );
+        }
+    }
+}
+
+/// Default bytecode VM must match the tree-walking interpreter for every MVP program.
+#[test]
+fn test_mvp_programs_interp_vm_stdout_parity() {
+    let core_dir = core_dir();
+    let bin = tish_bin();
+    assert!(
+        bin.exists(),
+        "tish binary not found at {}. Run `cargo build -p tishlang` first.",
+        bin.display()
+    );
+    for name in &discover_core_tests() {
+        if VM_PARITY_SKIP.contains(&name.as_str()) {
+            continue;
+        }
+        let path = core_dir.join(name);
+        if !path.exists() {
+            continue;
+        }
+        let path_str = path.to_string_lossy();
+        let out_interp = Command::new(&bin)
+            .args(["run", path_str.as_ref(), "--backend", "interp"])
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish interpreter");
+        assert!(
+            out_interp.status.success(),
+            "Interpreter failed for {}: {}",
+            path.display(),
+            String::from_utf8_lossy(&out_interp.stderr)
+        );
+        let out_vm = Command::new(&bin)
+            .args(["run", path_str.as_ref()])
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish VM");
+        assert!(
+            out_vm.status.success(),
+            "VM failed for {}: {}",
+            path.display(),
+            String::from_utf8_lossy(&out_vm.stderr)
+        );
+        let s_interp = String::from_utf8_lossy(&out_interp.stdout);
+        let s_vm = String::from_utf8_lossy(&out_vm.stdout);
+        assert_eq!(
+            s_interp,
+            s_vm,
+            "interp vs VM stdout mismatch for {}",
+            path.display()
+        );
+    }
+}
+
+/// Compile each .tish file to native, run, and compare stdout to static expected (parallelized).
+#[test]
+fn test_mvp_programs_native() {
+    let _fast_native = EnvVarGuard::set("TISH_FAST_NATIVE_BUILD", "1");
+    let core_dir = core_dir();
+    let bin = tish_bin();
+    assert!(
+        bin.exists(),
+        "tish binary not found at {}. Run `cargo build -p tishlang` first.",
+        bin.display()
+    );
+
+    let mut paths: Vec<PathBuf> = discover_core_tests()
+        .iter()
+        .filter_map(|name| {
+            let p = core_dir.join(name);
+            if p.exists() {
+                Some(p)
+            } else {
+                None
+            }
+        })
+        .collect();
+    paths.sort();
+
+    if paths.is_empty() {
+        return;
+    }
+
+    let combined = combined_mvp_native_inputs_hash(&paths);
+    let cache_dir = mvp_native_batch_cache_dir(combined);
+    let _ = std::fs::create_dir_all(&cache_dir);
+
+    let ext = if cfg!(target_os = "windows") {
+        ".exe"
+    } else {
+        ""
+    };
+
+    let entries_owned: Vec<(PathBuf, PathBuf)> = paths
+        .iter()
+        .map(|p| {
+            let stem = p.file_stem().unwrap().to_string_lossy();
+            let cached = cache_dir.join(format!("{}{}", stem, ext));
+            (p.clone(), cached)
+        })
+        .collect();
+
+    let need_build = entries_owned.iter().any(|(_, o)| !o.exists());
+    if need_build {
+        let refs: Vec<(&Path, &Path)> = entries_owned
+            .iter()
+            .map(|(a, b)| (a.as_path(), b.as_path()))
+            .collect();
+        let feats = native_build_features_for_integration_test();
+        compile_many_to_native(&refs, Some(workspace_root().as_path()), &feats, true)
+            .unwrap_or_else(|e| panic!("compile_many_to_native: {}", e.message));
+    }
+
+    // Run each binary sequentially. Parallel `fs::copy` + `exec` caused Linux ETXTBSY (errno 26)
+    // in CI when several threads replaced/ran temp executables under load.
+    let errors: Vec<String> = entries_owned
+        .iter()
+        .enumerate()
+        .filter_map(|(run_index, (path, cached_bin))| {
+            let expected = match get_expected(path) {
+                Some(e) => e,
+                None => return Some(format!("missing expected: {}", path.display())),
+            };
+            if !cached_bin.exists() {
+                return Some(format!("missing cached binary: {}", cached_bin.display()));
+            }
+            let stem = path.file_stem().unwrap().to_string_lossy();
+            let ext_bin = cached_bin
+                .extension()
+                .map(|e| e.to_string_lossy().to_string())
+                .unwrap_or_default();
+            let temp_dest = std::env::temp_dir().join(format!(
+                "tish_mvp_native_{}_{:x}_{}_{}",
+                stem,
+                file_content_hash(path),
+                std::process::id(),
+                run_index
+            ));
+            let temp_dest = if ext_bin.is_empty() {
+                temp_dest
+            } else {
+                temp_dest.with_extension(&ext_bin)
+            };
+            std::fs::copy(cached_bin, &temp_dest).expect("copy cached native bin to temp");
+            let out_bin = temp_dest;
+            let out = match Command::new(&out_bin)
+                .current_dir(workspace_root())
+                .output()
+            {
+                Ok(o) => o,
+                Err(e) => {
+                    let _ = std::fs::remove_file(&out_bin);
+                    return Some(format!("{}: run failed: {}", path.display(), e));
+                }
+            };
+            let _ = std::fs::remove_file(&out_bin);
+            if !out.status.success() {
+                return Some(format!(
+                    "{}: {}",
+                    path.display(),
+                    String::from_utf8_lossy(&out.stderr)
+                ));
+            }
+            let stdout = String::from_utf8_lossy(&out.stdout);
+            if stdout != expected {
+                return Some(format!("{}: output mismatch", path.display()));
+            }
+            None
+        })
+        .collect();
+    assert!(errors.is_empty(), "native failures:\n{}", errors.join("\n"));
+}
+
+// cranelift + wasi now use `discover_core_tests()` (full file discovery), like interp/vm/native —
+// the former curated `CRANELIFT_TEST_FILES` allowlist is gone. They embed the bytecode VM, which
+// has full interp↔vm parity (`VM_PARITY_SKIP` empty), so they inherit it: a disk-safe sweep confirmed
+// cranelift 66/66 and wasi 66/66. The old blocker was build COST — each backend build used to emit a
+// per-program `target/` (~2-5 GB) that accumulated to ~130 GB; now `tish_cranelift`/`tish_wasm` build
+// into a SHARED target dir so the deps compile once (610 MB / 85 MB total for the whole sweep, and a
+// repeat build is ~1 s). If a construct ever regresses on a backend, add it to a documented skip set
+// rather than re-introducing an allowlist.
+
+/// Compile each .tish file with Cranelift backend, run, and compare stdout to static expected (parallelized).
+#[test]
+fn test_mvp_programs_cranelift() {
+    let core_dir = core_dir();
+    let bin = tish_bin();
+    assert!(
+        bin.exists(),
+        "tish binary not found at {}. Run `cargo build -p tishlang` first.",
+        bin.display()
+    );
+    let errors: Vec<String> = discover_core_tests()
+        .par_iter()
+        .filter_map(|name| {
+            let path = core_dir.join(name);
+            if !path.exists() {
+                return None;
+            }
+            let expected = match get_expected(&path) {
+                Some(e) => e,
+                None => return Some(format!("missing expected: {}", path.display())),
+            };
+            let out_bin = compile_cached(&bin, &path, "cranelift");
+            let out = match Command::new(&out_bin)
+                .current_dir(workspace_root())
+                .output()
+            {
+                Ok(o) => o,
+                Err(e) => {
+                    let _ = std::fs::remove_file(&out_bin);
+                    return Some(format!("{}: run failed: {}", path.display(), e));
+                }
+            };
+            let _ = std::fs::remove_file(&out_bin);
+            if !out.status.success() {
+                return Some(format!(
+                    "{}: {}",
+                    path.display(),
+                    String::from_utf8_lossy(&out.stderr)
+                ));
+            }
+            let stdout = String::from_utf8_lossy(&out.stdout);
+            if stdout != expected {
+                return Some(format!("{}: output mismatch", path.display()));
+            }
+            None
+        })
+        .collect();
+    assert!(
+        errors.is_empty(),
+        "cranelift failures:\n{}",
+        errors.join("\n")
+    );
+}
+
+/// Compile each .tish file to WASI, run with wasmtime, and compare stdout to static expected (parallelized).
+/// Skips if wasmtime is not available.
+#[test]
+fn test_mvp_programs_wasi() {
+    let wasmtime_available = Command::new("wasmtime")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if !wasmtime_available {
+        eprintln!("Skipping test_mvp_programs_wasi: wasmtime not found");
+        return;
+    }
+    let core_dir = core_dir();
+    let bin = tish_bin();
+    assert!(
+        bin.exists(),
+        "tish binary not found at {}. Run `cargo build -p tishlang` first.",
+        bin.display()
+    );
+    let errors: Vec<String> = discover_core_tests()
+        .par_iter()
+        .filter_map(|name| {
+            let path = core_dir.join(name);
+            if !path.exists() {
+                return None;
+            }
+            let expected = match get_expected(&path) {
+                Some(e) => e,
+                None => return Some(format!("missing expected: {}", path.display())),
+            };
+            let out_wasm = compile_cached(&bin, &path, "wasi");
+            let out = match Command::new("wasmtime")
+                .arg(out_wasm.as_os_str())
+                .current_dir(workspace_root())
+                .output()
+            {
+                Ok(o) => o,
+                Err(e) => {
+                    let _ = std::fs::remove_file(&out_wasm);
+                    return Some(format!("{}: wasmtime failed: {}", path.display(), e));
+                }
+            };
+            let _ = std::fs::remove_file(&out_wasm);
+            if !out.status.success() {
+                return Some(format!(
+                    "{}: {}",
+                    path.display(),
+                    String::from_utf8_lossy(&out.stderr)
+                ));
+            }
+            let stdout = String::from_utf8_lossy(&out.stdout);
+            if stdout != expected {
+                return Some(format!("{}: output mismatch", path.display()));
+            }
+            None
+        })
+        .collect();
+    assert!(errors.is_empty(), "wasi failures:\n{}", errors.join("\n"));
+}
+
+/// Files where Tish intentionally differs from JavaScript (typeof, void); skip in JS test since we compare to Tish expected.
+const JS_SKIP_FILES: &[&str] = &["typeof.tish", "void.tish"];
+
+/// Compile each .tish file to JS, run with Node, and compare stdout to static expected.
+#[test]
+fn test_mvp_programs_js() {
+    let node_available = Command::new("node")
+        .args(["--version"])
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if !node_available {
+        eprintln!("Skipping test_mvp_programs_js: Node.js not found");
+        return;
+    }
+    let core_dir = core_dir();
+    let bin = tish_bin();
+    assert!(
+        bin.exists(),
+        "tish binary not found at {}. Run `cargo build -p tishlang` first.",
+        bin.display()
+    );
+    for name in &discover_core_tests() {
+        // intentional JS divergences + tests without a `.js` sibling can't use the Node oracle
+        if JS_SKIP_FILES.contains(&name.as_str()) || !has_js_sibling(name) {
+            continue;
+        }
+        let path = core_dir.join(name);
+        if !path.exists() {
+            continue;
+        }
+        let expected = get_expected(&path).unwrap_or_else(|| {
+            panic!(
+                "missing expected file for {}; run with REGENERATE_EXPECTED=1 to generate",
+                path.display()
+            )
+        });
+        let out_js = compile_cached(&bin, &path, "js");
+        let out = Command::new("node")
+            .arg(&out_js)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run node");
+        let _ = std::fs::remove_file(&out_js);
+        assert!(
+            out.status.success(),
+            "Node failed for {}: {}",
+            path.display(),
+            String::from_utf8_lossy(&out.stderr)
+        );
+        let stdout = String::from_utf8_lossy(&out.stdout);
+        assert_eq!(
+            stdout,
+            expected,
+            "JS output mismatch for {}",
+            path.display()
+        );
+    }
+}