@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_vm/tests/fixtures/or_string_cmd.tish

@@ -0,0 +1,2 @@
+let cmd = "a"
+if (cmd === "a" || cmd === "b") { console.log("hit") } else { console.log("miss") }

package/crates/tish_vm/tests/lexical_scope_declare.rs

@@ -0,0 +1,34 @@
+//! `DeclareVar` + block scopes: function `let` shadows script-level names (bytecode VM).
+
+use tishlang_bytecode::compile;
+use tishlang_vm::run;
+
+#[test]
+fn declare_var_shadows_script_let_inside_fn() {
+    let src = r#"
+let x = 1
+fn f() {
+  let x = 2
+  return x
+}
+let r = f()
+console.log("script", x, "fn", r)
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    run(&chunk).expect("run");
+}
+
+#[test]
+fn block_let_restores_outer_binding() {
+    let src = r#"
+let x = 1
+{
+  let x = 2
+}
+console.log(x)
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    run(&chunk).expect("run");
+}

package/crates/tish_vm/tests/peephole_jump_chain_logical_or.rs

@@ -0,0 +1,150 @@
+//! Regression: bytecode peephole `chain_jumps` must not follow `JumpIfFalse` as if it were an
+//! unconditional `Jump`. Doing so broke `===` + `||` when nested as the condition of an outer `if`
+//! (default VM differed from `--backend interp` / `--no-optimize`).
+//!
+//! CLI parity for the same source is covered in `crates/tish/tests/run_optimize_stdout_parity.rs`.
+
+use std::path::PathBuf;
+
+use tishlang_bytecode::{
+    compile, compile_for_repl, compile_for_repl_unoptimized, compile_unoptimized,
+};
+use tishlang_core::Value;
+
+fn run_chunk(chunk: &tishlang_bytecode::Chunk) -> Value {
+    tishlang_vm::run(chunk).expect("vm run")
+}
+
+/// `tish run` ends with trailing `null` when the last statement is not a REPL-style expr; use
+/// `compile_for_repl` so the VM return value reflects the `||` result (catches peephole/AST bugs).
+#[test]
+fn string_strict_eq_logical_or_repl_last_expr_is_true() {
+    let src = "let cmd = \"a\"\ncmd === \"a\" || cmd === \"b\"";
+    let opt = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&opt).expect("compile repl"));
+    let v_unopt = run_chunk(&compile_for_repl_unoptimized(&opt).expect("compile repl unopt"));
+    assert!(
+        v_peep.strict_eq(&v_unopt),
+        "peephole vs unopt repl: peep={v_peep:?} unopt={v_unopt:?}"
+    );
+    assert!(
+        matches!(&v_peep, Value::Bool(true)),
+        "expected true for cmd===a||cmd===b with cmd=a, got {v_peep:?}"
+    );
+}
+
+/// `?:` uses different codegen than `if`; both must agree with unoptimized bytecode.
+#[test]
+fn string_strict_eq_logical_or_inside_ternary_repl_last_expr() {
+    // Statement boundary: without `;` or `;`-like ASI, the parser can tie the `(` line to `let`.
+    let src = "let cmd = \"a\"\n;(cmd === \"a\" || cmd === \"b\") ? 1 : 0";
+    let opt = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&opt).expect("compile repl"));
+    let v_unopt = run_chunk(&compile_for_repl_unoptimized(&opt).expect("compile repl unopt"));
+    assert!(
+        v_peep.strict_eq(&v_unopt),
+        "peep={v_peep:?} unopt={v_unopt:?}"
+    );
+    assert!(
+        matches!(&v_peep, Value::Number(n) if *n == 1.0),
+        "expected 1, got {v_peep:?}"
+    );
+}
+
+#[test]
+fn logical_or_strict_eq_peephole_matches_unoptimized() {
+    let src = "let a = 1\nlet b = 2\na === 1 || b === 2";
+    let program = tishlang_parser::parse(src).expect("parse");
+    let program = tishlang_opt::optimize(&program);
+
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("compile unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "peephole changed semantics: peep={v_peep:?} raw={v_raw:?}"
+    );
+
+    let v_peep_repl = run_chunk(&compile_for_repl(&program).expect("compile repl"));
+    let v_raw_repl =
+        run_chunk(&compile_for_repl_unoptimized(&program).expect("compile repl unopt"));
+    assert!(
+        v_peep_repl.strict_eq(&v_raw_repl),
+        "repl: peep={v_peep_repl:?} raw={v_raw_repl:?}"
+    );
+}
+
+#[test]
+fn logical_or_inside_if_condition_peephole_matches_unoptimized() {
+    let src = "let a = 1\nlet b = 2\nif (a === 1 || b === 2) { 1 } else { 0 }";
+    let program = tishlang_parser::parse(src).expect("parse");
+    let program = tishlang_opt::optimize(&program);
+
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("compile unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "if + || : peep={v_peep:?} raw={v_raw:?}"
+    );
+}
+
+#[test]
+fn string_strict_eq_logical_or_ast_opt_matches_unoptimized_bytecode() {
+    let src = "let cmd = \"a\"\nif (cmd === \"a\" || cmd === \"b\") { 1 } else { 0 }";
+    let raw = tishlang_parser::parse(src).expect("parse");
+    let opt = tishlang_opt::optimize(&raw);
+    let v_raw = run_chunk(&compile_unoptimized(&raw).expect("raw"));
+    let v_opt = run_chunk(&compile_unoptimized(&opt).expect("opt"));
+    assert!(
+        v_raw.strict_eq(&v_opt),
+        "AST optimizer changed semantics: raw={v_raw:?} opt={v_opt:?}"
+    );
+}
+
+#[test]
+fn string_strict_eq_logical_or_peephole_matches_unoptimized() {
+    let src = "let cmd = \"a\"\nif (cmd === \"a\" || cmd === \"b\") { 1 } else { 0 }";
+    let program = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "peephole + strings: peep={v_peep:?} raw={v_raw:?}"
+    );
+}
+
+/// `tish run path/to/file.tish` uses merge_modules; ensure that matches plain parse for the fixture.
+#[test]
+fn merged_module_program_bytecode_matches_parse_for_string_or_fixture() {
+    let fixture =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/or_string_cmd.tish");
+    let src = std::fs::read_to_string(&fixture).expect("read fixture");
+    let modules = tishlang_compile::resolve_project(&fixture, Some(fixture.parent().unwrap()))
+        .expect("resolve");
+    let merged = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
+    let flat = tishlang_parser::parse(&src).expect("parse");
+    let m_opt = tishlang_opt::optimize(&merged);
+    let f_opt = tishlang_opt::optimize(&flat);
+    let c_m = compile(&m_opt).expect("compile merged");
+    let c_f = compile(&f_opt).expect("compile flat");
+    assert_eq!(
+        c_m.code, c_f.code,
+        "merge_modules vs parse produced different bytecode"
+    );
+}
+
+/// `if (cmd === "a" || cmd === "b")` must match unoptimized VM semantics (Nop padding from other
+/// peepholes must not confuse `chain_jumps`).
+#[test]
+fn string_eq_or_in_if_stmt_matches_unoptimized_repl() {
+    let src = "let cmd = \"a\"\nlet ok = false\nif (cmd === \"a\" || cmd === \"b\") { ok = true } else { ok = false }\nok";
+    let program = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&program).expect("compile repl"));
+    let v_raw = run_chunk(&compile_for_repl_unoptimized(&program).expect("compile repl unopt"));
+    assert!(v_peep.strict_eq(&v_raw), "peep={v_peep:?} raw={v_raw:?}");
+    assert!(
+        matches!(&v_peep, Value::Bool(true)),
+        "expected ok=true, got {v_peep:?}"
+    );
+}

package/crates/tish_wasm/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tishlang_wasm"
+version = "0.1.0"
+edition = "2021"
+description = "WebAssembly backend for Tish - compiles to real .wasm"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+[dependencies]
+tishlang_build_utils = { path = "../tish_build_utils", version = ">=0.1" }
+tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
+tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
+tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
+base64 = "0.22"

package/crates/tish_wasm/src/lib.rs

@@ -0,0 +1,424 @@
+//! WebAssembly backend for Tish.
+//!
+//! Compiles Tish to bytecode, then produces a .wasm VM binary + loader.
+//! The VM runs in the browser; your program runs as serialized bytecode.
+
+use std::collections::BTreeSet;
+use std::path::Path;
+use std::process::Command;
+
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
+
+use tishlang_ast::Program;
+use tishlang_bytecode::{serialize, Chunk};
+use tishlang_compile::{
+    detect_cycles, extract_native_import_features, has_external_native_imports, merge_modules,
+    resolve_project,
+};
+
+/// Error from WASM compilation.
+#[derive(Debug)]
+pub struct WasmError {
+    pub message: String,
+}
+
+impl std::fmt::Display for WasmError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for WasmError {}
+
+/// Map CLI / import capability names to `tishlang_wasm_runtime` Cargo features for wasm32-wasip1.
+/// The full `http` stack (tokio/socket2/…) does not build on WASI here; `http` maps to `promise`
+/// so `Promise` / `await` work. `ws` is skipped for the same reason.
+fn insert_wasi_runtime_cap(out: &mut BTreeSet<String>, cap: &str) {
+    match cap {
+        "http" => {
+            out.insert("promise".to_string());
+        }
+        "ws" => {}
+        "fs" | "process" | "promise" | "timers" | "regex" => {
+            out.insert(cap.to_string());
+        }
+        _ => {}
+    }
+}
+
+/// Resolve project, merge modules, and compile to bytecode chunk.
+/// Returns (Chunk, Program) so WASI can extract features for the runtime.
+fn resolve_and_compile_to_chunk(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    optimize: bool,
+) -> Result<(Chunk, Program), WasmError> {
+    let modules = resolve_project(entry_path, project_root).map_err(|e| WasmError {
+        message: e.to_string(),
+    })?;
+    detect_cycles(&modules).map_err(|e| WasmError {
+        message: e.to_string(),
+    })?;
+    let program = {
+        let prog = merge_modules(modules)
+            .map(|m| m.program)
+            .map_err(|e| WasmError {
+                message: e.to_string(),
+            })?;
+        if optimize {
+            tishlang_opt::optimize(&prog)
+        } else {
+            prog
+        }
+    };
+    let chunk = if optimize {
+        tishlang_bytecode::compile(&program).map_err(|e| WasmError {
+            message: e.to_string(),
+        })?
+    } else {
+        tishlang_bytecode::compile_unoptimized(&program).map_err(|e| WasmError {
+            message: e.to_string(),
+        })?
+    };
+    Ok((chunk, program))
+}
+
+/// Compile a single Program (e.g. from tishlang_js_to_tish) for WebAssembly.
+pub fn compile_program_to_wasm(
+    program: &Program,
+    output_path: &Path,
+    optimize: bool,
+) -> Result<(), WasmError> {
+    let program = if optimize {
+        tishlang_opt::optimize(program)
+    } else {
+        program.clone()
+    };
+    let chunk = if optimize {
+        tishlang_bytecode::compile(&program).map_err(|e| WasmError {
+            message: e.to_string(),
+        })?
+    } else {
+        tishlang_bytecode::compile_unoptimized(&program).map_err(|e| WasmError {
+            message: e.to_string(),
+        })?
+    };
+    emit_wasm_from_chunk(&chunk, output_path)
+}
+
+fn emit_wasm_from_chunk(chunk: &Chunk, output_path: &Path) -> Result<(), WasmError> {
+    let chunk_bytes = serialize(chunk);
+    let chunk_b64 = BASE64.encode(&chunk_bytes);
+    let stem = output_path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("main");
+    let out_dir = output_path
+        .parent()
+        .filter(|p| !p.as_os_str().is_empty())
+        .unwrap_or(Path::new("."));
+    let out_dir_abs = out_dir
+        .canonicalize()
+        .or_else(|_| std::env::current_dir().map(|cwd| cwd.join(out_dir)))
+        .map_err(|e| WasmError {
+            message: format!("Cannot resolve output dir: {}", e),
+        })?;
+    std::fs::create_dir_all(&out_dir_abs).map_err(|e| WasmError {
+        message: format!("Cannot create output directory: {}", e),
+    })?;
+    let workspace_root =
+        tishlang_build_utils::find_workspace_root().map_err(|e| WasmError { message: e })?;
+    let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
+    let build_status = Command::new(&cargo)
+        .current_dir(&workspace_root)
+        .args([
+            "build",
+            "-p",
+            "tishlang_wasm_runtime",
+            "--target",
+            "wasm32-unknown-unknown",
+            "--release",
+            "--features",
+            "browser",
+        ])
+        .status()
+        .map_err(|e| WasmError {
+            message: format!("Failed to run cargo: {}", e),
+        })?;
+    if !build_status.success() {
+        return Err(WasmError {
+            message: "Failed to build wasm runtime. Run: rustup target add wasm32-unknown-unknown"
+                .to_string(),
+        });
+    }
+    let wasm_artifact =
+        workspace_root.join("target/wasm32-unknown-unknown/release/tishlang_wasm_runtime.wasm");
+    if !wasm_artifact.exists() {
+        return Err(WasmError {
+            message: format!("Wasm artifact not found: {}", wasm_artifact.display()),
+        });
+    }
+    let wasm_bindgen = std::env::var("WASM_BINDGEN").unwrap_or_else(|_| "wasm-bindgen".to_string());
+    let out_name = stem.to_string();
+    let bindgen_status = Command::new(&wasm_bindgen)
+        .args([
+            "--target",
+            "web",
+            "--out-dir",
+            out_dir_abs.to_str().unwrap(),
+            "--out-name",
+            &out_name,
+            wasm_artifact.to_str().unwrap(),
+        ])
+        .status()
+        .map_err(|e| WasmError {
+            message: format!(
+                "Failed to run wasm-bindgen: {}. Install with: cargo install wasm-bindgen-cli",
+                e
+            ),
+        })?;
+    if !bindgen_status.success() {
+        return Err(WasmError {
+            message: "wasm-bindgen failed".to_string(),
+        });
+    }
+    let js_name = format!("{}.js", stem);
+    let html = format!(
+        r#"<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><title>{}</title></head>
+<body>
+<script type="module">
+const CHUNK_B64 = "{}";
+const chunk = Uint8Array.from(atob(CHUNK_B64), c => c.charCodeAt(0));
+import init, {{ run }} from './{}';
+await init();
+run(chunk);
+</script>
+</body>
+</html>
+"#,
+        stem, chunk_b64, js_name
+    );
+    let html_path = out_dir_abs.join(format!("{}.html", stem));
+    std::fs::write(&html_path, html).map_err(|e| WasmError {
+        message: format!("Cannot write {}: {}", html_path.display(), e),
+    })?;
+    println!(
+        "Built: {}_bg.wasm, {}.js, {}",
+        stem,
+        stem,
+        html_path.display()
+    );
+    Ok(())
+}
+
+/// Compile a Tish project for WebAssembly.
+///
+/// Produces:
+/// - `{output}.wasm` — VM binary (runs your program)
+/// - `{output}.js` — wasm-bindgen glue
+/// - `{output}.html` — loader (open in browser)
+///
+/// Requires: `rustup target add wasm32-unknown-unknown`, `wasm-bindgen-cli`
+pub fn compile_to_wasm(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    optimize: bool,
+) -> Result<(), WasmError> {
+    let (chunk, _) = resolve_and_compile_to_chunk(entry_path, project_root, optimize)?;
+    emit_wasm_from_chunk(&chunk, output_path)
+}
+
+/// Compile a Tish project to a raw serialized bytecode chunk.
+///
+/// Writes a single `{output}` file of the exact bytes that the wasm/WASI runtime entry points
+/// (`start` / `run`) deserialize directly — the same chunk `--target wasm` embeds as base64 in
+/// its generated HTML loader, but written raw with no VM binary, JS glue, or HTML wrapper. Lets a
+/// host that already ships the VM runtime (e.g. a bundler) consume the bytecode without the
+/// throwaway standalone build.
+pub fn compile_to_bytecode(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    optimize: bool,
+) -> Result<(), WasmError> {
+    let (chunk, _) = resolve_and_compile_to_chunk(entry_path, project_root, optimize)?;
+    let bytes = serialize(&chunk);
+    if let Some(parent) = output_path.parent().filter(|p| !p.as_os_str().is_empty()) {
+        std::fs::create_dir_all(parent).map_err(|e| WasmError {
+            message: format!("Cannot create output directory: {}", e),
+        })?;
+    }
+    std::fs::write(output_path, &bytes).map_err(|e| WasmError {
+        message: format!("Cannot write {}: {}", output_path.display(), e),
+    })?;
+    println!("Built: {} ({} bytes)", output_path.display(), bytes.len());
+    Ok(())
+}
+
+/// Compile a Tish project for Wasmtime/WASI.
+///
+/// Produces a single `{output}.wasm` with embedded bytecode. Run with:
+/// `wasmtime {output}.wasm`
+///
+/// Requires: `rustup target add wasm32-wasip1`
+///
+/// `capabilities` is the same capability list as `tish build --target native` (e.g. from
+/// `native_build_features_from_cli`): merged with `import`-inferred features so globals like
+/// `Promise` / `fetch` work without a top-level `import … from 'http'`.
+pub fn compile_to_wasi(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    optimize: bool,
+    capabilities: &[String],
+) -> Result<(), WasmError> {
+    let (chunk, program) = resolve_and_compile_to_chunk(entry_path, project_root, optimize)?;
+    if has_external_native_imports(&program) {
+        return Err(WasmError {
+            message: "WASI backend does not support external native imports (tish:egui, @scope/pkg). Built-in tish:fs, tish:http, tish:process, tish:timers are supported.".to_string(),
+        });
+    }
+    let mut wasi_feature_set: BTreeSet<String> = BTreeSet::new();
+    for f in extract_native_import_features(&program) {
+        insert_wasi_runtime_cap(&mut wasi_feature_set, f.as_str());
+    }
+    for f in capabilities {
+        insert_wasi_runtime_cap(&mut wasi_feature_set, f.as_str());
+    }
+    // Many scripts use global setTimeout without `import` from timers.
+    wasi_feature_set.insert("timers".to_string());
+
+    let chunk_bytes = serialize(&chunk);
+
+    let stem = output_path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("main");
+    let out_dir = output_path
+        .parent()
+        .filter(|p| !p.as_os_str().is_empty())
+        .unwrap_or(Path::new("."));
+    let out_dir_abs = out_dir
+        .canonicalize()
+        .or_else(|_| std::env::current_dir().map(|cwd| cwd.join(out_dir)))
+        .map_err(|e| WasmError {
+            message: format!("Cannot resolve output dir: {}", e),
+        })?;
+
+    std::fs::create_dir_all(&out_dir_abs).map_err(|e| WasmError {
+        message: format!("Cannot create output directory: {}", e),
+    })?;
+
+    let workspace_root =
+        tishlang_build_utils::find_workspace_root().map_err(|e| WasmError { message: e })?;
+
+    // Create generated project: wasi_build/{stem}/
+    let build_dir = out_dir_abs.join("wasi_build").join(stem);
+    std::fs::create_dir_all(build_dir.join("src")).map_err(|e| WasmError {
+        message: format!("Cannot create build dir: {}", e),
+    })?;
+
+    // Write chunk.bin
+    std::fs::write(build_dir.join("chunk.bin"), &chunk_bytes).map_err(|e| WasmError {
+        message: format!("Cannot write chunk: {}", e),
+    })?;
+
+    // Cargo.toml - path to tishlang_wasm_runtime (crate in crates/tish_wasm_runtime)
+    let runtime_path = workspace_root.join("crates").join("tish_wasm_runtime");
+    let runtime_path_str = runtime_path
+        .canonicalize()
+        .unwrap_or(runtime_path)
+        .to_string_lossy()
+        .replace('\\', "/");
+
+    let features_str = format!(
+        ", features = [{}]",
+        wasi_feature_set
+            .iter()
+            .map(|f| format!("{:?}", f))
+            .collect::<Vec<_>>()
+            .join(", ")
+    );
+    let cargo_toml = format!(
+        r#"[package]
+name = "tish_wasi_{stem}"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+
+[[bin]]
+name = "tish_wasi_{stem}"
+path = "src/main.rs"
+
+[dependencies]
+tishlang_wasm_runtime = {{ path = "{runtime_path_str}"{features_str} }}
+"#,
+        stem = stem,
+        runtime_path_str = runtime_path_str,
+        features_str = features_str
+    );
+    std::fs::write(build_dir.join("Cargo.toml"), cargo_toml).map_err(|e| WasmError {
+        message: format!("Cannot write Cargo.toml: {}", e),
+    })?;
+
+    // main.rs
+    let main_rs = r#"
+fn main() {
+    let chunk = include_bytes!("../chunk.bin");
+    if let Err(e) = tishlang_wasm_runtime::run_wasi(chunk) {
+        eprintln!("Runtime error: {}", e);
+        std::process::exit(1);
+    }
+}
+"#;
+    std::fs::write(build_dir.join("src").join("main.rs"), main_rs).map_err(|e| WasmError {
+        message: format!("Cannot write main.rs: {}", e),
+    })?;
+
+    // Build - use explicit target-dir so we know where the artifact is
+    let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
+    let bin_name = format!("tish_wasi_{}", stem);
+    let target_dir = build_dir.join("target");
+    let build_status = Command::new(&cargo)
+        .current_dir(&build_dir)
+        .env("CARGO_TARGET_DIR", &target_dir)
+        .args(["build", "--target", "wasm32-wasip1", "--release"])
+        .status()
+        .map_err(|e| WasmError {
+            message: format!("Failed to run cargo: {}", e),
+        })?;
+
+    if !build_status.success() {
+        return Err(WasmError {
+            message: "Failed to build WASI binary. Run: rustup target add wasm32-wasip1"
+                .to_string(),
+        });
+    }
+
+    let wasm_artifact = target_dir
+        .join("wasm32-wasip1")
+        .join("release")
+        .join(format!("{}.wasm", bin_name));
+
+    if !wasm_artifact.exists() {
+        return Err(WasmError {
+            message: format!("WASI artifact not found: {}", wasm_artifact.display()),
+        });
+    }
+
+    let final_wasm = out_dir_abs.join(format!("{}.wasm", stem));
+    std::fs::copy(&wasm_artifact, &final_wasm).map_err(|e| WasmError {
+        message: format!("Cannot copy wasm: {}", e),
+    })?;
+
+    println!(
+        "Built: {} (run with: wasmtime {})",
+        final_wasm.display(),
+        final_wasm.display()
+    );
+    Ok(())
+}

package/crates/tish_wasm_runtime/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "tishlang_wasm_runtime"
+version = "0.1.0"
+edition = "2021"
+description = "Tish VM compiled to WebAssembly (browser + Wasmtime/WASI)"
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+# For wasm32-unknown-unknown (browser): wasm-bindgen, console output
+browser = ["dep:wasm-bindgen", "tishlang_vm/wasm"]
+# Browser WebGPU / JS-interop FFI + requestAnimationFrame render loop (the
+# `start(chunk, env)` entry). Reflection-based bridge over js-sys; no web-sys
+# WebGPU bindings needed since the WebGPU command API is synchronous.
+gpu = ["browser", "dep:js-sys"]
+# Built-in modules for WASI (wasm32-wasip1): align with `tishlang_cranelift_runtime` / CLI caps
+fs = ["tishlang_vm/fs"]
+process = ["tishlang_vm/process"]
+http = ["tishlang_vm/http"]
+promise = ["tishlang_vm/promise"]
+timers = ["tishlang_vm/timers"]
+regex = ["tishlang_vm/regex"]
+ws = ["tishlang_vm/ws"]
+
+[dependencies]
+tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
+tishlang_vm = { path = "../tish_vm", version = ">=0.1" }
+tishlang_core = { path = "../tish_core", version = ">=0.1" }
+wasm-bindgen = { version = "0.2", optional = true }
+js-sys = { version = "0.3", optional = true }
+
+# rand_core → getrandom 0.4 needs wasm_js on wasm32-unknown-unknown (browser VM build).
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.4", features = ["wasm_js"] }