@tishlang/tish 1.1.3 → 1.3.1

package/README.md

@@ -1,8 +1,8 @@
 # @tishlang/tish
 
-[Tish](https://github.com/tishlang/tish) is a minimal TypeScript/JavaScript–compatible language: run with an interpreter, use a REPL, or compile to native binaries.
+[Tish](https://github.com/tishlang/tish) is a minimal TypeScript/JavaScript–compatible language: run with an interpreter, use a REPL, or build native binaries and other targets.
 
-This npm package ships the **Tish CLI** for Node.js **22+**. It includes platform-specific native binaries; the `tish` command picks the right one for your OS and CPU.
+This npm package ships the **Tish CLI**. It includes platform-specific native binaries under `platform/`; **`npm install`** runs `postinstall`, which copies the correct binary to `bin/tish`. That file is what runs when you invoke `tish` — the CLI itself is native, not Node. Node **22+** is required for install scripts and tooling (e.g. semantic-release in this repo); the `tish` binary has no Node runtime dependency.
 
 ## Install
 
@@ -25,14 +25,14 @@ npx @tishlang/tish hello.tish
 npx @tishlang/tish run src/main.tish
 ```
 
-Compile to a native executable:
+Build a native executable:
 
 ```bash
-npx @tishlang/tish compile app.tish -o app
+npx @tishlang/tish build app.tish -o app
 ./app
 ```
 
-Native compilation uses the Rust backend by default (requires [Rust](https://rustup.rs) and `cargo` on your PATH). The package includes the Tish workspace source (`Cargo.toml`, `crates/`, `justfile`) so `tish compile` can run `cargo build` for your program. For pure Tish without native imports, use `--native-backend cranelift` (no Rust toolchain needed).
+Native builds use the Rust backend by default (requires [Rust](https://rustup.rs) and `cargo` on your PATH). The package includes the Tish workspace source (`Cargo.toml`, `crates/`, `justfile`) so `tish build` can run `cargo build` for your program. For pure Tish without native imports, use `--native-backend cranelift` (no Rust toolchain needed).
 
 Start the REPL:
 

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.1.3"
+version = "1.3.1"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/main.rs

@@ -1,10 +1,10 @@
-//! Tish CLI - run, REPL, compile to native.
+//! Tish CLI - run, REPL, build to native or other targets.
 
 mod repl_completion;
 
 use std::cell::RefCell;
 use std::fs;
-use std::io::{self, IsTerminal, Write};
+use std::io::{self, IsTerminal, Read, Write};
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 
@@ -23,7 +23,8 @@ pub(crate) struct Cli {
 
 #[derive(Parser)]
 struct RunArgs {
-    #[arg(required = true)]
+    /// Path to a `.tish` file, or `-` to read the program from stdin (like `node -`).
+    #[arg(required = true, allow_hyphen_values = true)]
     file: String,
     #[arg(long, default_value = "vm")]
     backend: String,
@@ -45,7 +46,7 @@ struct ReplArgs {
 }
 
 #[derive(Parser)]
-struct CompileArgs {
+struct BuildArgs {
     #[arg(short, long, default_value = "tish_out")]
     output: String,
     #[arg(long, default_value = "native")]
@@ -66,8 +67,8 @@ pub(crate) enum Commands {
     Run(RunArgs),
     /// Interactive REPL
     Repl(ReplArgs),
-    /// Compile to native binary or JavaScript
-    Compile(CompileArgs),
+    /// Build native binary, wasm, wasi, or JavaScript output
+    Build(BuildArgs),
     /// Parse and dump AST
     #[command(name = "dump-ast")]
     DumpAst {
@@ -76,15 +77,42 @@ pub(crate) enum Commands {
     },
 }
 
+/// `tish script.tish` → insert `run` so it matches `tish run script.tish` (npx / npm UX).
+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"];
+        let looks_like_file =
+            !first.starts_with('-') && !SUBCOMMANDS.iter().any(|&s| s == first);
+        if looks_like_file {
+            argv.insert(1, "run".to_string());
+        }
+    }
+    argv
+}
+
 fn main() {
-    let cli = Cli::parse();
     let no_opt_env = std::env::var_os("TISH_NO_OPTIMIZE")
         .map(|v| v == "1" || v == "true" || v == "yes")
         .unwrap_or(false);
+
+    // `tish -` (like `node -` / `bun -`); clap would treat `-` as an invalid subcommand.
+    let argv: Vec<String> = std::env::args().collect();
+    if argv.len() == 2 && argv[1] == "-" {
+        let result = run_stdin_pipe("vm", &[], no_opt_env, true);
+        if let Err(e) = result {
+            eprintln!("Error: {}", e);
+            std::process::exit(1);
+        }
+        return;
+    }
+
+    let argv = argv_with_implicit_run(argv);
+    let cli = Cli::parse_from(argv);
     let result = match cli.command {
         Some(Commands::Run(a)) => run_file(&a.file, &a.backend, &a.features, a.no_optimize || no_opt_env),
         Some(Commands::Repl(a)) => run_repl(&a.backend, a.no_optimize || no_opt_env),
-        Some(Commands::Compile(a)) => compile_file(
+        Some(Commands::Build(a)) => build_file(
             &a.file,
             &a.output,
             &a.target,
@@ -93,7 +121,14 @@ fn main() {
             a.no_optimize || no_opt_env,
         ),
         Some(Commands::DumpAst { file }) => dump_ast(&file),
-        None => run_repl("vm", false), // No args = REPL
+        None => {
+            if io::stdin().is_terminal() {
+                run_repl("vm", no_opt_env)
+            } else {
+                // `echo '...' | tish` — run script from stdin (Bun-style)
+                run_stdin_pipe("vm", &[], no_opt_env, false)
+            }
+        }
     };
 
     if let Err(e) = result {
@@ -102,49 +137,97 @@ fn main() {
     }
 }
 
-fn run_file(path: &str, backend: &str, _features: &[String], no_optimize: bool) -> Result<(), String> {
-    let path = Path::new(path).canonicalize().map_err(|e| format!("Cannot resolve {}: {}", path, e))?;
-    let project_root = path.parent().and_then(|p| {
-        if p.file_name().and_then(|n| n.to_str()) == Some("src") {
-            p.parent()
-        } else {
-            Some(p)
+/// Read stdin and run as Tish. If `fail_on_empty`, `tish run -` / `tish -` get an error; if false, empty stdin exits 0.
+fn run_stdin_pipe(
+    backend: &str,
+    features: &[String],
+    no_optimize: bool,
+    fail_on_empty: bool,
+) -> Result<(), String> {
+    let mut source = String::new();
+    io::stdin()
+        .read_to_string(&mut source)
+        .map_err(|e| format!("Cannot read stdin: {}", e))?;
+    if source.trim().is_empty() {
+        if fail_on_empty {
+            return Err(
+                "No source on stdin. Example: echo 'console.log(1)' | tish   or   tish run -".into(),
+            );
         }
-    });
+        return Ok(());
+    }
+    run_stdin_source(&source, backend, features, no_optimize)
+}
 
-    let program = if path.extension().map(|e| e == "js") == Some(true) {
-        let prog = tishlang_js_to_tish::convert(&fs::read_to_string(&path).map_err(|e| format!("{}", e))?)
-            .map_err(|e| format!("{}", e))?;
-        if no_optimize {
-            prog
-        } else {
-            tishlang_opt::optimize(&prog)
-        }
+fn run_stdin_source(
+    source: &str,
+    backend: &str,
+    _features: &[String],
+    no_optimize: bool,
+) -> Result<(), String> {
+    let cwd = std::env::current_dir().map_err(|e| e.to_string())?;
+    let modules = tishlang_compile::resolve_project_from_stdin(source, &cwd)?;
+    tishlang_compile::detect_cycles(&modules)?;
+    let prog = tishlang_compile::merge_modules(modules)?;
+    let program = if no_optimize {
+        prog
+    } else {
+        tishlang_opt::optimize(&prog)
+    };
+    run_program(&program, backend, no_optimize)
+}
+
+fn run_file(path: &str, backend: &str, features: &[String], no_optimize: bool) -> Result<(), String> {
+    let program = if path == "-" {
+        return run_stdin_pipe(backend, features, no_optimize, true);
     } else {
-        let modules = tishlang_compile::resolve_project(&path, project_root)?;
-        tishlang_compile::detect_cycles(&modules)?;
-        let prog = tishlang_compile::merge_modules(modules)?;
-        if no_optimize {
-            prog
+        let path =
+            Path::new(path).canonicalize().map_err(|e| format!("Cannot resolve {}: {}", path, e))?;
+        let project_root = path.parent().and_then(|p| {
+            if p.file_name().and_then(|n| n.to_str()) == Some("src") {
+                p.parent()
+            } else {
+                Some(p)
+            }
+        });
+
+        if path.extension().map(|e| e == "js") == Some(true) {
+            let prog = tishlang_js_to_tish::convert(&fs::read_to_string(&path).map_err(|e| format!("{}", e))?)
+                .map_err(|e| format!("{}", e))?;
+            if no_optimize {
+                prog
+            } else {
+                tishlang_opt::optimize(&prog)
+            }
         } else {
-            tishlang_opt::optimize(&prog)
+            let modules = tishlang_compile::resolve_project(&path, project_root)?;
+            tishlang_compile::detect_cycles(&modules)?;
+            let prog = tishlang_compile::merge_modules(modules)?;
+            if no_optimize {
+                prog
+            } else {
+                tishlang_opt::optimize(&prog)
+            }
         }
     };
 
+    run_program(&program, backend, no_optimize)
+}
+
+fn run_program(program: &tishlang_ast::Program, backend: &str, no_optimize: bool) -> Result<(), String> {
     if backend == "interp" {
         let mut eval = tishlang_eval::Evaluator::new();
-        let value = eval.eval_program(&program)?;
+        let value = eval.eval_program(program)?;
         if !matches!(value, tishlang_eval::Value::Null) {
             println!("{}", tishlang_eval::format_value_for_console(&value, tishlang_core::use_console_colors()));
         }
         return Ok(());
     }
 
-    // VM backend (bytecode) - supports native imports when built with fs/http/process features
     let chunk = if no_optimize {
-        tishlang_bytecode::compile_unoptimized(&program).map_err(|e| e.to_string())?
+        tishlang_bytecode::compile_unoptimized(program).map_err(|e| e.to_string())?
     } else {
-        tishlang_bytecode::compile(&program).map_err(|e| e.to_string())?
+        tishlang_bytecode::compile(program).map_err(|e| e.to_string())?
     };
     let value = tishlang_vm::run(&chunk)?;
     if !matches!(value, tishlang_core::Value::Null) {
@@ -385,7 +468,7 @@ fn compile_to_js(input_path: &Path, output_path: &str, optimize: bool) -> Result
 }
 
 #[allow(clippy::vec_init_then_push)]
-fn compile_file(
+fn build_file(
     input_path: &str,
     output_path: &str,
     target: &str,
@@ -509,13 +592,36 @@ fn compile_file(
 mod cli_tests {
     use clap::Parser;
 
-    use super::{Cli, Commands};
+    use super::{argv_with_implicit_run, Cli, Commands};
+
+    #[test]
+    fn implicit_run_inserts_run_before_file() {
+        let argv = argv_with_implicit_run(vec![
+            "tish".to_string(),
+            "hello.tish".to_string(),
+        ]);
+        let cli = Cli::try_parse_from(argv).unwrap();
+        match cli.command {
+            Some(Commands::Run(a)) => assert_eq!(a.file, "hello.tish"),
+            _ => panic!("expected Run"),
+        }
+    }
+
+    #[test]
+    fn explicit_subcommand_not_treated_as_file() {
+        let argv = argv_with_implicit_run(vec![
+            "tish".to_string(),
+            "repl".to_string(),
+        ]);
+        let cli = Cli::try_parse_from(argv).unwrap();
+        assert!(matches!(cli.command, Some(Commands::Repl(_))));
+    }
 
     #[test]
-    fn compile_js_target_parses() {
+    fn build_js_target_parses() {
         let cli = Cli::try_parse_from([
             "tish",
-            "compile",
+            "build",
             "m.tish",
             "--target",
             "js",
@@ -524,8 +630,17 @@ mod cli_tests {
         ])
         .unwrap();
         match cli.command {
-            Some(Commands::Compile(a)) => assert_eq!(a.file, "m.tish"),
-            _ => panic!("expected Compile"),
+            Some(Commands::Build(a)) => assert_eq!(a.file, "m.tish"),
+            _ => panic!("expected Build"),
+        }
+    }
+
+    #[test]
+    fn run_stdin_marker_parses_as_file() {
+        let cli = Cli::try_parse_from(["tish", "run", "-"]).unwrap();
+        match cli.command {
+            Some(Commands::Run(a)) => assert_eq!(a.file, "-"),
+            _ => panic!("expected Run"),
         }
     }
 }

package/crates/tish/tests/integration_test.rs

@@ -40,7 +40,7 @@ fn target_dir() -> PathBuf {
         .unwrap_or_else(|_| workspace_root().join("target"))
 }
 
-/// Cache dir for tish compile outputs (under target/ so CI rust-cache restores it).
+/// 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")
 }
@@ -56,7 +56,7 @@ fn file_content_hash(path: &Path) -> u64 {
 }
 
 /// Compile a .tish file with the given backend, using a persistent cache so we only run
-/// `tish compile` when the file or backend changed. Returns path to the compiled artifact
+/// `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
@@ -73,7 +73,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             let ext = if cfg!(target_os = "windows") { ".exe" } else { "" };
             let cached = cache_base.join(format!("{}_{}{}", stem, hash8, ext));
             let args = vec![
-                OsString::from("compile"),
+                OsString::from("build"),
                 OsString::from(path),
                 OsString::from("-o"),
                 OsString::from(&cached),
@@ -84,7 +84,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             let ext = if cfg!(target_os = "windows") { ".exe" } else { "" };
             let cached = cache_base.join(format!("{}_{}{}", stem, hash8, ext));
             let args = vec![
-                OsString::from("compile"),
+                OsString::from("build"),
                 OsString::from(path),
                 OsString::from("-o"),
                 OsString::from(&cached),
@@ -96,7 +96,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
         "js" => {
             let cached = cache_base.join(format!("{}_{}.js", stem, hash8));
             let args = vec![
-                OsString::from("compile"),
+                OsString::from("build"),
                 OsString::from(path),
                 OsString::from("--target"),
                 OsString::from("js"),
@@ -109,7 +109,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             let out_base = cache_base.join(format!("{}_{}", stem, hash8));
             let artifact = out_base.with_extension("wasm");
             let args = vec![
-                OsString::from("compile"),
+                OsString::from("build"),
                 OsString::from(path),
                 OsString::from("-o"),
                 OsString::from(&out_base),
@@ -126,7 +126,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             .args(compile_args)
             .current_dir(workspace_root())
             .output()
-            .expect("run tish compile");
+            .expect("run tish build");
         assert!(
             out.status.success(),
             "Compile failed for {} ({}): {}",
@@ -203,13 +203,13 @@ fn test_async_await_compile_via_binary() {
     if path.exists() && bin.exists() {
         let out = std::env::temp_dir().join("tish_async_test_out");
         let compile_result = Command::new(&bin)
-            .args(["compile", path.to_string_lossy().as_ref(), "-o", out.to_string_lossy().as_ref()])
+            .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 compile");
+        let compile_out = compile_result.expect("run tish build");
         assert!(
             compile_out.status.success(),
-            "tish compile failed: {}",
+            "tish build failed: {}",
             String::from_utf8_lossy(&compile_out.stderr)
         );
         // Run compiled binary to validate non-blocking fetchAll executes correctly
@@ -245,13 +245,13 @@ fn test_async_parallel_vs_sequential_timing() {
 
     // Compile both
     let compile_par = Command::new(&bin)
-        .args(["compile", parallel_src.to_string_lossy().as_ref(), "-o", out_parallel.to_string_lossy().as_ref()])
+        .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(["compile", sequential_src.to_string_lossy().as_ref(), "-o", out_sequential.to_string_lossy().as_ref()])
+        .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));

package/crates/tish_builtins/src/construct.rs

@@ -1,5 +1,5 @@
 //! `new` lowering for non-JS targets: `construct(callee, args)` approximates JS `[[Construct]]`.
-//! Browser-exact behavior remains on `tish compile --target js`.
+//! Browser-exact behavior remains on `tish build --target js`.
 
 use std::cell::RefCell;
 use std::rc::Rc;

package/crates/tish_compile/src/lib.rs

@@ -15,7 +15,7 @@ pub use codegen::CompileError;
 pub use resolve::{
     detect_cycles, extract_native_import_features, has_external_native_imports, has_native_imports,
     is_builtin_native_spec, merge_modules, resolve_native_modules, resolve_project,
-    ResolvedNativeModule,
+    resolve_project_from_stdin, ResolvedNativeModule,
 };
 pub use types::{RustType, TypeContext};
 

package/crates/tish_compile/src/resolve.rs

@@ -242,6 +242,59 @@ pub fn resolve_project(
         .collect())
 }
 
+/// Resolve modules when the entry program is read from stdin (`tish run -`).
+/// Relative file imports resolve from `project_root` (typically [`std::env::current_dir()`]).
+/// The synthetic entry path `<stdin>` is not a real file; dependencies load from disk as usual.
+pub fn resolve_project_from_stdin(
+    source: &str,
+    project_root: &Path,
+) -> Result<Vec<ResolvedModule>, String> {
+    let root_canon = project_root
+        .canonicalize()
+        .map_err(|e| format!("Cannot canonicalize project root {}: {}", project_root.display(), e))?;
+
+    let stdin_path = root_canon.join("<stdin>");
+    let program = tishlang_parser::parse(source)
+        .map_err(|e| format!("Parse error (stdin): {}", e))?;
+
+    let mut visited = HashSet::new();
+    let mut path_to_module: HashMap<PathBuf, Program> = HashMap::new();
+    let mut load_order: Vec<PathBuf> = Vec::new();
+
+    let from_dir = stdin_path
+        .parent()
+        .unwrap_or_else(|| Path::new("."));
+
+    for stmt in &program.statements {
+        if let Statement::Import { from, .. } = stmt {
+            if is_native_import(from) {
+                continue;
+            }
+            let dep_path = resolve_import_path(from, from_dir, &root_canon)?;
+            if !path_to_module.contains_key(&dep_path) {
+                load_module_recursive(
+                    &dep_path,
+                    &root_canon,
+                    &mut visited,
+                    &mut path_to_module,
+                    &mut load_order,
+                )?;
+            }
+        }
+    }
+
+    path_to_module.insert(stdin_path.clone(), program);
+    load_order.push(stdin_path);
+
+    Ok(load_order
+        .into_iter()
+        .map(|p| {
+            let program = path_to_module.remove(&p).unwrap();
+            ResolvedModule { path: p, program }
+        })
+        .collect())
+}
+
 fn load_module_recursive(
     module_path: &Path,
     project_root: &Path,

package/crates/tish_cranelift_runtime/src/lib.rs

@@ -1,4 +1,4 @@
-//! Runtime linked into the `tish compile --native-backend cranelift` executable.
+//! Runtime linked into the `tish build --native-backend cranelift` executable.
 //!
 //! **`tish_run_chunk`** deserializes embedded bytecode and runs **`tishlang_vm`** — the same
 //! execution engine as `tish run --backend vm`. The crate name is historical; this is not

package/crates/tish_eval/src/eval.rs

@@ -1593,7 +1593,7 @@ impl Evaluator {
                 self.construct_value(&c, &arg_vals)
             }
             Expr::JsxElement { .. } | Expr::JsxFragment { .. } => Err(EvalError::Error(
-                "JSX is not supported in the interpreter. Use 'tish compile --target js' to compile to JavaScript.".to_string(),
+                "JSX is not supported in the interpreter. Use 'tish build --target js' to compile to JavaScript.".to_string(),
             )),
             Expr::NativeModuleLoad { spec, export_name, .. } => {
                 self.load_builtin_export(spec.as_ref(), export_name.as_ref())

package/justfile

@@ -9,8 +9,8 @@
 #      just run run hello.tish           # runs via interpreter
 #      tish run hello.tish               # if tish is in PATH
 #
-# 2. BUILD (Compile to Native) - Create standalone executable:
-#      just run compile hello.tish -o hello   # compiles to native binary
+# 2. BUILD (native binary) - Create standalone executable:
+#      just run build hello.tish -o hello   # builds native binary
 #      ./hello                                 # run the standalone binary
 #
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -72,17 +72,17 @@ run-regex *ARGS:
     cargo run --release --no-default-features --features regex -- {{ARGS}}
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# COMPILE TISH PROGRAMS TO NATIVE BINARIES
+# BUILD TISH PROGRAMS TO NATIVE BINARIES (just recipe name: compile → invokes `tish build`)
 # ═══════════════════════════════════════════════════════════════════════════════
 
-# Compile a .tish file to native binary (with all features)
+# Build a .tish file to native binary (with all features)
 # Usage: just compile hello.tish hello
 compile INPUT OUTPUT:
-    cargo run --release --features full -- compile {{INPUT}} -o {{OUTPUT}}
+    cargo run --release --features full -- build {{INPUT}} -o {{OUTPUT}}
 
 # Compile with secure mode (no dangerous features)
 compile-secure INPUT OUTPUT:
-    cargo run --release --no-default-features -- compile {{INPUT}} -o {{OUTPUT}}
+    cargo run --release --no-default-features -- build {{INPUT}} -o {{OUTPUT}}
 
 # Build compiler WASM (for playground, REPL, try-it). Output: tish_compiler.js, tish_compiler_bg.wasm
 # Requires: rustup target add wasm32-unknown-unknown, cargo install wasm-bindgen-cli
@@ -94,17 +94,17 @@ build-compiler-wasm OUT_DIR:
 # Compile to WebAssembly (browser) - produces .wasm, .js, .html
 # Requires: rustup target add wasm32-unknown-unknown, cargo install wasm-bindgen-cli
 compile-wasm INPUT OUTPUT:
-    cargo run --release -- compile {{INPUT}} -o {{OUTPUT}} --target wasm
+    cargo run --release -- build {{INPUT}} -o {{OUTPUT}} --target wasm
 
 # Compile to WebAssembly (Wasmtime/WASI) - single .wasm, run with: wasmtime OUTPUT.wasm
 # Requires: rustup target add wasm32-wasip1, wasmtime (curl -sSf https://wasmtime.dev/install.sh | bash)
 compile-wasi INPUT OUTPUT:
-    cargo run --release -- compile {{INPUT}} -o {{OUTPUT}} --target wasi
+    cargo run --release -- build {{INPUT}} -o {{OUTPUT}} --target wasi
 
 # Compile with specific features
 # Usage: just compile-with "http fs" hello.tish hello
 compile-with FEATURES INPUT OUTPUT:
-    cargo run --release --no-default-features --features "{{FEATURES}}" -- compile {{INPUT}} -o {{OUTPUT}}
+    cargo run --release --no-default-features --features "{{FEATURES}}" -- build {{INPUT}} -o {{OUTPUT}}
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # TESTS

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.1.3",
-  "description": "Tish - minimal TS/JS-compatible language. Run, REPL, compile to native.",
+  "version": "1.3.1",
+  "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -11,10 +11,14 @@
     "access": "public"
   },
   "bin": {
-    "tish": "./bin/tish.js"
+    "tish": "./bin/tish"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install-bin.js"
   },
   "files": [
     "bin",
+    "scripts/install-bin.js",
     "platform",
     "README.md",
     "LICENSE",

package/scripts/install-bin.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Copy platform/<os>-<arch>/tish to bin/tish so the npm bin is the native binary.
+ * Runs on postinstall and before npm pack in CI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const platformKey = `${process.platform}-${process.arch}`;
+const binaryName = process.platform === 'win32' ? 'tish.exe' : 'tish';
+
+const root = path.join(__dirname, '..');
+const src = path.join(root, 'platform', platformKey, binaryName);
+const dest = path.join(root, 'bin', 'tish');
+
+if (!fs.existsSync(src)) {
+  if (process.env.TISH_NPM_PACK_REQUIRE === '1') {
+    console.error(`[tish] No prebuilt binary for this platform: ${platformKey}`);
+    console.error(`[tish] Expected: ${src}`);
+    process.exit(1);
+  }
+  console.warn(`[tish] Skipping native bin (not found for ${platformKey}): ${src}`);
+  console.warn('[tish] From repo root run: ./npm/scripts/build-binaries.sh — then: node npm/tish/scripts/install-bin.js');
+  process.exit(0);
+}
+
+fs.mkdirSync(path.dirname(dest), { recursive: true });
+fs.copyFileSync(src, dest);
+try {
+  fs.chmodSync(dest, 0o755);
+} catch (_) {
+  /* Windows may ignore chmod */
+}

package/bin/tish.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const path = require('path');
-const fs = require('fs');
-const { spawnSync } = require('child_process');
-
-const platformKey = `${process.platform}-${process.arch}`;
-const supported = ['darwin-arm64', 'darwin-x64', 'linux-x64', 'linux-arm64', 'win32-x64'];
-const binaryName = process.platform === 'win32' ? 'tish.exe' : 'tish';
-
-const binPath = path.join(__dirname, '..', 'platform', platformKey, binaryName);
-if (!fs.existsSync(binPath)) {
-  console.error(`[tish] Unsupported or missing binary for platform: ${platformKey}`);
-  console.error('Supported:', supported.join(', '));
-  console.error('Build from source: https://github.com/tishlang/tish');
-  process.exit(1);
-}
-
-// Convenience: "npx @tishlang/tish FILE [args]" → "tish run FILE [args]"
-const args = process.argv.slice(2);
-const subcommands = ['run', 'repl', 'compile', 'dump-ast'];
-const first = args[0];
-const looksLikeFile = first && !first.startsWith('-') && !subcommands.includes(first);
-
-const finalArgs = looksLikeFile ? ['run', ...args] : args;
-
-const result = spawnSync(binPath, finalArgs, {
-  stdio: 'inherit',
-  windowsHide: true,
-});
-process.exit(result.status !== null ? result.status : 1);