@tishlang/tish 1.9.2 → 1.10.0

package/crates/tish_wasm/src/lib.rs

@@ -30,6 +30,22 @@ impl std::fmt::Display for WasmError {
 
 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(
@@ -47,8 +63,8 @@ fn resolve_and_compile_to_chunk(
         let prog = merge_modules(modules)
             .map(|m| m.program)
             .map_err(|e| WasmError {
-            message: e.to_string(),
-        })?;
+                message: e.to_string(),
+            })?;
         if optimize {
             tishlang_opt::optimize(&prog)
         } else {
@@ -221,11 +237,16 @@ pub fn compile_to_wasm(
 /// `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) {
@@ -233,7 +254,16 @@ pub fn compile_to_wasi(
             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 wasi_features = extract_native_import_features(&program);
+    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
@@ -277,10 +307,6 @@ pub fn compile_to_wasi(
         .to_string_lossy()
         .replace('\\', "/");
 
-    // Bundled perf (`tests/main.tish`) and many scripts use global setTimeout without a top-level
-    // `import` (so `extract_native_import_features` is empty). Always link timers for WASI VM.
-    let mut wasi_feature_set: BTreeSet<String> = wasi_features.into_iter().collect();
-    wasi_feature_set.insert("timers".to_string());
     let features_str = format!(
         ", features = [{}]",
         wasi_feature_set

package/crates/tish_wasm_runtime/Cargo.toml

@@ -12,11 +12,14 @@ crate-type = ["cdylib", "rlib"]
 [features]
 # For wasm32-unknown-unknown (browser): wasm-bindgen, console output
 browser = ["dep:wasm-bindgen", "tishlang_vm/wasm"]
-# Built-in modules for WASI (wasm32-wasip1): file I/O, process, http, timers
+# 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" }

package/crates/tish_wasm_runtime/src/lib.rs

@@ -2,7 +2,8 @@
 //!
 //! Two targets:
 //! - **Browser** (wasm32-unknown-unknown): use `--features browser`, wasm-bindgen, console output
-//! - **WASI/Wasmtime** (wasm32-wasip1): optional `timers` / `http` / … via Cargo features; `compile_to_wasi` enables `timers` by default.
+//! - **WASI/Wasmtime** (wasm32-wasip1): optional `timers` / `http` / … via Cargo features; `compile_to_wasi`
+//!   merges CLI capability flags with imports and always enables `timers` when globals use `setTimeout`.
 
 use tishlang_bytecode::deserialize;
 use tishlang_vm::Vm;

package/crates/tishlang_cargo_bindgen/src/classify.rs

@@ -1,8 +1,6 @@
 //! Classify a `pub fn` from syn for glue emission (driven by signature shape, not crate name).
 
-use syn::{
-    FnArg, GenericArgument, ItemFn, PathArguments, ReturnType, Type, TypeReference,
-};
+use syn::{FnArg, GenericArgument, ItemFn, PathArguments, ReturnType, Type, TypeReference};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum SignatureClass {

package/crates/tishlang_cargo_bindgen/src/discover.rs

@@ -26,8 +26,10 @@ pub fn discover_public_functions(crate_root: &Path) -> Result<HashMap<String, It
         .filter(|e| e.path().extension().map(|x| x == "rs").unwrap_or(false))
     {
         let path = entry.path();
-        let text = fs::read_to_string(path).map_err(|e| format!("read {}: {}", path.display(), e))?;
-        let file = syn::parse_file(&text).map_err(|e| format!("parse {}: {}", path.display(), e))?;
+        let text =
+            fs::read_to_string(path).map_err(|e| format!("read {}: {}", path.display(), e))?;
+        let file =
+            syn::parse_file(&text).map_err(|e| format!("parse {}: {}", path.display(), e))?;
 
         for item in file.items {
             if let Item::Fn(f) = item {
@@ -70,8 +72,10 @@ pub fn rust_public_fn_location(
         .filter(|e| e.path().extension().map(|x| x == "rs").unwrap_or(false))
     {
         let path = entry.path();
-        let text = fs::read_to_string(path).map_err(|e| format!("read {}: {}", path.display(), e))?;
-        let file = syn::parse_file(&text).map_err(|e| format!("parse {}: {}", path.display(), e))?;
+        let text =
+            fs::read_to_string(path).map_err(|e| format!("read {}: {}", path.display(), e))?;
+        let file =
+            syn::parse_file(&text).map_err(|e| format!("parse {}: {}", path.display(), e))?;
 
         for item in file.items {
             if let Item::Fn(f) = item {
@@ -85,7 +89,8 @@ pub fn rust_public_fn_location(
                 let line = u32::try_from(lc.line)
                     .map_err(|_| "span line out of range".to_string())?
                     .saturating_sub(1);
-                let col = u32::try_from(lc.column).map_err(|_| "span column out of range".to_string())?;
+                let col =
+                    u32::try_from(lc.column).map_err(|_| "span column out of range".to_string())?;
                 return Ok((path.to_path_buf(), line, col));
             }
         }

package/crates/tishlang_cargo_bindgen/src/infer.rs

@@ -28,7 +28,8 @@ pub fn select_glue_crate_from_package_json(
             e
         )
     })?;
-    let j: Value = serde_json::from_str(&raw).map_err(|e| format!("{}: {}", pkg_json_path.display(), e))?;
+    let j: Value =
+        serde_json::from_str(&raw).map_err(|e| format!("{}: {}", pkg_json_path.display(), e))?;
     let rust_deps = j
         .get("tish")
         .and_then(|t| t.get("rustDependencies"))
@@ -123,7 +124,8 @@ fn dep_version_req_string_glue(spec: &toml::Value) -> Result<String, String> {
 }
 
 /// Crates we ignore when inferring bindgen **upstream** from the **app** `Cargo.toml` (not the glue crate).
-const ROOT_MANIFEST_SKIP_DEPS: &[&str] = &["tishlang_runtime", "tishlang_core", "tishlang_build_utils"];
+const ROOT_MANIFEST_SKIP_DEPS: &[&str] =
+    &["tishlang_runtime", "tishlang_core", "tishlang_build_utils"];
 
 /// Registry semver for bindgen metadata probe; skips path/git/workspace-only entries (project root fallback).
 fn dep_version_req_string_root(spec: &toml::Value) -> Option<String> {
@@ -136,7 +138,9 @@ fn dep_version_req_string_root(spec: &toml::Value) -> Option<String> {
             if t.get("path").is_some() || t.get("git").is_some() {
                 return None;
             }
-            t.get("version").and_then(|v| v.as_str()).map(|s| s.to_string())
+            t.get("version")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
         }
         _ => None,
     }
@@ -209,13 +213,15 @@ fn disambiguate_upstream_candidates(
 /// disambiguating when `serde_json` is present as a JSON-bridge helper alongside another crate.
 pub fn parse_upstream_from_glue_cargo(cargo_toml_path: &Path) -> Result<(String, String), String> {
     let s = fs::read_to_string(cargo_toml_path).map_err(|e| e.to_string())?;
-    let root: toml::Value = toml::from_str(&s).map_err(|e| format!("{}: {}", cargo_toml_path.display(), e))?;
+    let root: toml::Value =
+        toml::from_str(&s).map_err(|e| format!("{}: {}", cargo_toml_path.display(), e))?;
     let deps = root
         .get("dependencies")
         .and_then(|d| d.as_table())
         .ok_or_else(|| format!("{} has no [dependencies]", cargo_toml_path.display()))?;
 
-    let candidates = collect_upstream_candidates_from_table(deps, &[], dep_version_req_string_glue)?;
+    let candidates =
+        collect_upstream_candidates_from_table(deps, &[], dep_version_req_string_glue)?;
     disambiguate_upstream_candidates(
         candidates,
         cargo_toml_path,
@@ -226,9 +232,12 @@ pub fn parse_upstream_from_glue_cargo(cargo_toml_path: &Path) -> Result<(String,
 /// Infer upstream from the **project** `Cargo.toml` when the glue crate does not exist yet.
 /// Uses `[dependencies]` and `[dev-dependencies]`, skips Tish toolchain path crates (`tishlang_core`, …),
 /// and only keeps entries with a registry semver (skips bare `path =` / `git` deps).
-pub fn parse_upstream_from_root_package_cargo(cargo_toml_path: &Path) -> Result<(String, String), String> {
+pub fn parse_upstream_from_root_package_cargo(
+    cargo_toml_path: &Path,
+) -> Result<(String, String), String> {
     let s = fs::read_to_string(cargo_toml_path).map_err(|e| e.to_string())?;
-    let root: toml::Value = toml::from_str(&s).map_err(|e| format!("{}: {}", cargo_toml_path.display(), e))?;
+    let root: toml::Value =
+        toml::from_str(&s).map_err(|e| format!("{}: {}", cargo_toml_path.display(), e))?;
 
     let mut candidates = root
         .get("dependencies")
@@ -255,7 +264,8 @@ pub fn infer_from_project_root(
     project_root: &Path,
     rust_dep_key: Option<&str>,
 ) -> Result<InferredProjectBindgen, String> {
-    let (output_crate_name, out_dir) = select_glue_crate_from_package_json(project_root, rust_dep_key)?;
+    let (output_crate_name, out_dir) =
+        select_glue_crate_from_package_json(project_root, rust_dep_key)?;
     let glue_cargo = out_dir.join("Cargo.toml");
     let root_cargo = project_root.join("Cargo.toml");
 

package/crates/tishlang_cargo_bindgen/src/lib.rs

@@ -22,7 +22,9 @@ mod metadata;
 
 pub use classify::SignatureClass;
 pub use discover::rust_public_fn_location;
-pub use metadata::{resolve_dependency_from_manifest, resolve_registry_dependency, ResolvedDependency};
+pub use metadata::{
+    resolve_dependency_from_manifest, resolve_registry_dependency, ResolvedDependency,
+};
 
 use std::fs;
 use std::io;
@@ -69,7 +71,10 @@ pub fn generate_from_manifest(
     generate_from_resolved(cfg, &resolved)
 }
 
-fn generate_from_resolved(cfg: &BindgenConfig, resolved: &ResolvedDependency) -> Result<(), String> {
+fn generate_from_resolved(
+    cfg: &BindgenConfig,
+    resolved: &ResolvedDependency,
+) -> Result<(), String> {
     let root = resolved.source_root();
     let fns = discover::discover_public_functions(&root)?;
 
@@ -102,17 +107,9 @@ fn generate_from_resolved(cfg: &BindgenConfig, resolved: &ResolvedDependency) ->
         emitted.push((export.clone(), class));
     }
 
-    let lib_rs = render_generated_lib(
-        &cfg.dependency_name,
-        &emitted,
-        need_json_helpers,
-    )?;
+    let lib_rs = render_generated_lib(&cfg.dependency_name, &emitted, need_json_helpers)?;
 
-    let cargo_toml = render_output_cargo_toml(
-        cfg,
-        resolved.version(),
-        need_json_helpers,
-    )?;
+    let cargo_toml = render_output_cargo_toml(cfg, resolved.version(), need_json_helpers)?;
 
     fs::create_dir_all(cfg.out_dir.join("src")).map_err(|e| e.to_string())?;
     fs::write(cfg.out_dir.join("Cargo.toml"), cargo_toml).map_err(|e| e.to_string())?;
@@ -128,16 +125,18 @@ impl BindgenConfig {
     }
 }
 
-fn render_output_cargo_toml(cfg: &BindgenConfig, dep_exact_version: &str, need_serde_json: bool) -> Result<String, String> {
+fn render_output_cargo_toml(
+    cfg: &BindgenConfig,
+    dep_exact_version: &str,
+    need_serde_json: bool,
+) -> Result<String, String> {
     let rt_line = match &cfg.tishlang_runtime {
-        TishlangRuntimeDep::Path(p) => format!(
-            "tishlang_runtime = {{ path = {} }}\n",
-            toml_string_value(p)
-        ),
-        TishlangRuntimeDep::Version(req) => format!(
-            "tishlang_runtime = {}\n",
-            toml_string_value(req)
-        ),
+        TishlangRuntimeDep::Path(p) => {
+            format!("tishlang_runtime = {{ path = {} }}\n", toml_string_value(p))
+        }
+        TishlangRuntimeDep::Version(req) => {
+            format!("tishlang_runtime = {}\n", toml_string_value(req))
+        }
     };
     let dep_line = format!(
         "{} = {}\n",
@@ -185,10 +184,7 @@ fn render_generated_lib(
          use tishlang_runtime::{ObjectMap, Value, VmRef};\n\n",
     );
 
-    out.push_str(&format!(
-        "use {} as _tish_upstream;\n\n",
-        crate_ident
-    ));
+    out.push_str(&format!("use {} as _tish_upstream;\n\n", crate_ident));
 
     if need_json_helpers {
         out.push_str(JSON_HELPERS);
@@ -318,7 +314,10 @@ fn canonical_path_string(p: &Path) -> Result<String, String> {
 }
 
 /// Relative path from `out_dir` to `runtime` for Cargo.toml `path =`.
-pub fn runtime_path_relative_to_out_dir(out_dir: &Path, runtime: impl AsRef<Path>) -> Result<String, String> {
+pub fn runtime_path_relative_to_out_dir(
+    out_dir: &Path,
+    runtime: impl AsRef<Path>,
+) -> Result<String, String> {
     let abs_rt = runtime
         .as_ref()
         .canonicalize()

package/crates/tishlang_cargo_bindgen/src/main.rs

@@ -8,7 +8,8 @@ use std::path::PathBuf;
 use clap::Parser;
 use tishlang_cargo_bindgen::{
     generate_from_manifest, generate_from_registry_dependency, infer,
-    resolve_runtime_path_for_output, runtime_path_relative_to_out_dir, BindgenConfig, TishlangRuntimeDep,
+    resolve_runtime_path_for_output, runtime_path_relative_to_out_dir, BindgenConfig,
+    TishlangRuntimeDep,
 };
 
 #[derive(Parser, Debug)]
@@ -83,49 +84,51 @@ fn run() -> Result<(), String> {
 
     let current_dir = std::env::current_dir().map_err(|e| e.to_string())?;
 
-    let (
-        output_crate_name,
-        out_dir,
-        dependency_name,
-        dependency_version_req,
-        search_root,
-    ) = if let Some(dep) = args.dependency.as_ref() {
-        if let Some(out) = args.out_dir.as_ref() {
+    let (output_crate_name, out_dir, dependency_name, dependency_version_req, search_root) =
+        if let Some(dep) = args.dependency.as_ref() {
+            if let Some(out) = args.out_dir.as_ref() {
+                let root = args
+                    .project_root
+                    .clone()
+                    .unwrap_or_else(|| out.parent().unwrap_or(out).to_path_buf());
+                (
+                    args.crate_name
+                        .clone()
+                        .unwrap_or_else(|| "tish_serde_json".into()),
+                    out.clone(),
+                    dep.clone(),
+                    args.dependency_version.clone(),
+                    root,
+                )
+            } else {
+                let root = args
+                    .project_root
+                    .clone()
+                    .unwrap_or_else(|| current_dir.clone());
+                let (crate_key, od) =
+                    infer::infer_glue_paths_only(&root, args.crate_name.as_deref())?;
+                (
+                    crate_key,
+                    od,
+                    dep.clone(),
+                    args.dependency_version.clone(),
+                    root,
+                )
+            }
+        } else {
             let root = args
                 .project_root
                 .clone()
-                .unwrap_or_else(|| out.parent().unwrap_or(out).to_path_buf());
+                .unwrap_or_else(|| current_dir.clone());
+            let inf = infer::infer_from_project_root(&root, args.crate_name.as_deref())?;
             (
-                args.crate_name
-                    .clone()
-                    .unwrap_or_else(|| "tish_serde_json".into()),
-                out.clone(),
-                dep.clone(),
-                args.dependency_version.clone(),
+                inf.output_crate_name,
+                inf.out_dir,
+                inf.dependency_name,
+                inf.dependency_version_req,
                 root,
             )
-        } else {
-            let root = args.project_root.clone().unwrap_or_else(|| current_dir.clone());
-            let (crate_key, od) = infer::infer_glue_paths_only(&root, args.crate_name.as_deref())?;
-            (
-                crate_key,
-                od,
-                dep.clone(),
-                args.dependency_version.clone(),
-                root,
-            )
-        }
-    } else {
-        let root = args.project_root.clone().unwrap_or_else(|| current_dir.clone());
-        let inf = infer::infer_from_project_root(&root, args.crate_name.as_deref())?;
-        (
-            inf.output_crate_name,
-            inf.out_dir,
-            inf.dependency_name,
-            inf.dependency_version_req,
-            root,
-        )
-    };
+        };
 
     let tishlang_runtime = if let Some(req) = args.tishlang_runtime_version.clone() {
         TishlangRuntimeDep::Version(req)

package/crates/tishlang_cargo_bindgen/src/metadata.rs

@@ -35,7 +35,10 @@ fn from_package(pkg: &Package) -> ResolvedDependency {
 }
 
 /// Build a tiny probe crate, run `cargo metadata`, and return the named package.
-pub fn resolve_registry_dependency(name: &str, version_req: &str) -> Result<ResolvedDependency, String> {
+pub fn resolve_registry_dependency(
+    name: &str,
+    version_req: &str,
+) -> Result<ResolvedDependency, String> {
     let probe_dir = tempfile::tempdir().map_err(|e| format!("tempdir: {}", e))?;
     let probe_toml = format!(
         r#"[package]

package/justfile

@@ -125,15 +125,15 @@ test *ARGS:
 
 # Run only tish package tests (same as CI: integration tests only)
 test-tish *ARGS:
-    cargo nextest run -p tishlang--features full -- {{ARGS}}
+    cargo nextest run -p tishlang --features full -- {{ARGS}}
 
 # Skip slow backend tests (native/cranelift/wasi) for fast local iteration
 test-quick:
-    cargo nextest run -p tishlang--features full -- --skip test_mvp_programs_native --skip test_mvp_programs_cranelift --skip test_mvp_programs_wasi
+    cargo nextest run -p tishlang --features full -- --skip test_mvp_programs_native --skip test_mvp_programs_cranelift --skip test_mvp_programs_wasi
 
 # Run tests with coverage (requires llvm-tools: rustup component add llvm-tools-preview)
 test-coverage:
-    cargo llvm-cov nextest -p tishlang--features full --lcov --output-path lcov.info --html coverage-html
+    cargo llvm-cov nextest -p tishlang --features full --lcov --output-path lcov.info --html coverage-html
 
 # Plain cargo test (whole workspace)
 test-cargo:

package/package.json

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