@tishlang/tish 2.2.7 → 2.9.0

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -4,7 +4,7 @@ mod tests {
 
     use tishlang_parser::parse;
 
-    use crate::{compile_project_with_jsx, compile_with_jsx};
+    use crate::{compile_project_esm, compile_project_with_jsx, compile_with_jsx, EmittedJsModule};
 
     #[test]
     fn lattish_jsx_emits_h_with_children_array() {
@@ -411,4 +411,232 @@ fn factory() {
             );
         }
     }
+
+    // tish `=== null` / `!== null` lower to JS `== null` / `!= null` so the nullish check catches the
+    // JS-runtime `undefined` (missing props / holes) too — matching interp/vm/native, which read a
+    // missing property back as null. Strict equality between non-null operands stays strict.
+    #[test]
+    fn strict_eq_null_lowers_to_loose_null() {
+        let program = parse("let x = 1\nconsole.log(x === null)\nconsole.log(x !== null)\n").unwrap();
+        let js = crate::compile(&program, false).unwrap();
+        assert!(!js.contains("=== null"), "`=== null` must lower to `== null`:\n{js}");
+        assert!(!js.contains("!== null"), "`!== null` must lower to `!= null`:\n{js}");
+        assert!(
+            js.contains("== null") && js.contains("!= null"),
+            "expected loose null checks:\n{js}"
+        );
+    }
+
+    #[test]
+    fn strict_eq_between_non_null_operands_stays_strict() {
+        let program = parse("let a = 1\nlet b = 2\nconsole.log(a === b)\nconsole.log(a !== b)\n").unwrap();
+        let js = crate::compile(&program, false).unwrap();
+        assert!(js.contains("==="), "non-null `===` must stay strict:\n{js}");
+        assert!(js.contains("!=="), "non-null `!==` must stay strict:\n{js}");
+    }
+
+    // `typeof null` is "null" in tish (interp/vm/native agree — null is a first-class type), not JS's
+    // `typeof null === "object"` wart. The JS backend must map a nullish operand to "null".
+    #[test]
+    fn typeof_null_emits_null_not_object() {
+        let program = parse("console.log(typeof null)\n").unwrap();
+        let js = crate::compile(&program, false).unwrap();
+        assert!(!js.contains("(typeof null)"), "must not emit raw `typeof null`:\n{js}");
+        assert!(js.contains("\"null\""), "typeof of a nullish value must yield \"null\":\n{js}");
+    }
+
+    // 1/0 and -1/0 fold to Infinity / -Infinity; emit the JS spellings, not Rust's `inf` / `-inf`
+    // (which would be undefined identifiers in the output).
+    #[test]
+    fn non_finite_number_literals_use_js_spellings() {
+        let pos = crate::compile(&parse("console.log(1 / 0)\n").unwrap(), true).unwrap();
+        assert!(pos.contains("Infinity"), "1/0 must emit Infinity:\n{pos}");
+        assert!(!pos.contains("inf"), "must not emit Rust's lowercase `inf`:\n{pos}");
+        let neg = crate::compile(&parse("console.log(-1 / 0)\n").unwrap(), true).unwrap();
+        assert!(neg.contains("-Infinity"), "-1/0 must emit -Infinity:\n{neg}");
+    }
+
+    // ── #282: ESM module output (one file per module, real import/export) ──────────────────────
+
+    /// Write a set of `(relative_path, source)` modules into a fresh temp dir and compile the entry
+    /// in ESM mode. Returns the emitted modules keyed for easy lookup by their output relative path.
+    fn build_esm(entry: &str, modules: &[(&str, &str)]) -> Vec<EmittedJsModule> {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        for (rel, src) in modules {
+            let p = dir.join(rel);
+            if let Some(parent) = p.parent() {
+                std::fs::create_dir_all(parent).unwrap();
+            }
+            let mut f = std::fs::File::create(&p).unwrap();
+            f.write_all(src.as_bytes()).unwrap();
+            f.sync_all().unwrap();
+        }
+        compile_project_esm(&dir.join(entry), Some(dir), false).expect("compile_project_esm failed")
+    }
+
+    fn module_js<'a>(mods: &'a [EmittedJsModule], rel: &str) -> &'a str {
+        mods.iter()
+            .find(|m| m.relative_path.to_string_lossy() == rel)
+            .map(|m| m.js.as_str())
+            .unwrap_or_else(|| panic!("module {rel} not emitted; got {:?}", mods.iter().map(|m| m.relative_path.display().to_string()).collect::<Vec<_>>()))
+    }
+
+    #[test]
+    fn esm_emits_named_and_default_exports() {
+        let mods = build_esm(
+            "main.tish",
+            &[(
+                "main.tish",
+                "export const VERSION = \"1.0\"\nexport fn greet(n) { return \"hi \" + n }\nexport default greet\n",
+            )],
+        );
+        let js = module_js(&mods, "main.js");
+        assert!(js.contains("export const VERSION = \"1.0\";"), "named const export:\n{js}");
+        assert!(js.contains("export function greet "), "named fn export:\n{js}");
+        assert!(js.contains("export default greet;"), "default export:\n{js}");
+    }
+
+    #[test]
+    fn esm_rewrites_import_specifier_to_js_with_alias() {
+        let mods = build_esm(
+            "main.tish",
+            &[
+                ("dep.tish", "export const ssrH = 42\nexport fn greet(n) { return n }\n"),
+                (
+                    "main.tish",
+                    "import { ssrH as h, greet } from \"./dep.tish\"\nimport * as M from \"./dep.tish\"\nconsole.log(h)\nconsole.log(greet(M.ssrH))\n",
+                ),
+            ],
+        );
+        let js = module_js(&mods, "main.js");
+        assert!(
+            js.contains("import { ssrH as h, greet } from \"./dep.js\";"),
+            "named import with alias, .tish->.js:\n{js}"
+        );
+        assert!(js.contains("import * as M from \"./dep.js\";"), "namespace import:\n{js}");
+    }
+
+    #[test]
+    fn esm_one_file_per_module_preserves_tree() {
+        let mods = build_esm(
+            "main.tish",
+            &[
+                ("lib/util.tish", "export fn id(x) { return x }\n"),
+                ("main.tish", "import { id } from \"./lib/util.tish\"\nconsole.log(id(1))\n"),
+            ],
+        );
+        // Nested module keeps its relative path; importer points at the nested `.js`.
+        let _ = module_js(&mods, "lib/util.js");
+        let main = module_js(&mods, "main.js");
+        assert!(
+            main.contains("from \"./lib/util.js\";"),
+            "nested relative import preserved:\n{main}"
+        );
+    }
+
+    #[test]
+    fn esm_module_outside_project_root_is_emitted() {
+        // #282 follow-up: a dependency in a *sibling* package (outside the entry's project root)
+        // must still be emitted — the output tree is rooted at the directory common to all modules.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let base = tmp.path();
+        std::fs::create_dir_all(base.join("app/src")).unwrap();
+        std::fs::create_dir_all(base.join("lib")).unwrap();
+        std::fs::write(base.join("lib/util.tish"), "export fn id(x) { return x }\n").unwrap();
+        std::fs::write(
+            base.join("app/src/main.tish"),
+            "import { id } from \"../../lib/util.tish\"\nconsole.log(id(1))\n",
+        )
+        .unwrap();
+        // Project root is the entry's package (`app`); `lib/util.tish` lives outside it.
+        let mods = compile_project_esm(
+            &base.join("app/src/main.tish"),
+            Some(&base.join("app")),
+            false,
+        )
+        .expect("compile_project_esm failed for sibling dep");
+        let rels: Vec<String> = mods
+            .iter()
+            .map(|m| m.relative_path.to_string_lossy().replace('\\', "/"))
+            .collect();
+        let main_js = mods
+            .iter()
+            .find(|m| m.relative_path.to_string_lossy().replace('\\', "/").ends_with("app/src/main.js"))
+            .map(|m| m.js.clone());
+        assert!(
+            rels.iter().any(|r| r.ends_with("lib/util.js")),
+            "sibling dep emitted under common base: {:?}",
+            rels
+        );
+        assert!(
+            rels.iter().any(|r| r.ends_with("app/src/main.js")),
+            "entry emitted under its own subtree: {:?}",
+            rels
+        );
+        let main_js = main_js.expect("entry module present");
+        assert!(
+            main_js.contains("from \"../../lib/util.js\";"),
+            "relative import to sibling rewritten to .js:\n{main_js}"
+        );
+    }
+
+    #[test]
+    fn esm_bare_node_modules_dep_is_emitted() {
+        // #282 follow-up: a bare specifier resolved from `node_modules` (like `lattish`) is emitted
+        // into the output tree and the importer points at it with a relative `.js` specifier.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let base = tmp.path();
+        std::fs::create_dir_all(base.join("src")).unwrap();
+        std::fs::create_dir_all(base.join("node_modules/pkg")).unwrap();
+        std::fs::write(
+            base.join("node_modules/pkg/package.json"),
+            "{\"name\":\"pkg\",\"main\":\"index.tish\"}\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("node_modules/pkg/index.tish"),
+            "export fn ping() { return \"pong\" }\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/main.tish"),
+            "import { ping } from \"pkg\"\nconsole.log(ping())\n",
+        )
+        .unwrap();
+        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false)
+            .expect("compile_project_esm failed for node_modules dep");
+        let rels: Vec<String> = mods
+            .iter()
+            .map(|m| m.relative_path.to_string_lossy().replace('\\', "/"))
+            .collect();
+        let main_js = mods
+            .iter()
+            .find(|m| m.relative_path.to_string_lossy().replace('\\', "/").ends_with("src/main.js"))
+            .map(|m| m.js.clone());
+        assert!(
+            rels.iter().any(|r| r.ends_with("node_modules/pkg/index.js")),
+            "node_modules dep emitted: {:?}",
+            rels
+        );
+        let main_js = main_js.expect("entry module present");
+        assert!(
+            main_js.contains("from \"../node_modules/pkg/index.js\";"),
+            "bare specifier rewritten to relative .js path:\n{main_js}"
+        );
+    }
+
+    #[test]
+    fn esm_rejects_native_imports() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "import { readFile } from \"fs\"\nconsole.log(1)\n").unwrap();
+        let err = compile_project_esm(&p, Some(dir), false).unwrap_err();
+        assert!(
+            err.message.contains("Native module import") && err.message.contains("esm"),
+            "expected a native-import rejection for ESM, got: {}",
+            err.message
+        );
+    }
 }

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -394,6 +394,7 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                             name: Arc::from(v.clone()),
                                             span: *span,
                                         },
+                                        *name_span,
                                     ));
                                 }
                                 statements.push(Statement::VarDecl {

package/crates/tish_core/Cargo.toml

@@ -23,6 +23,8 @@ ahash = "0.8.11"
 arcstr = "1"
 smallvec = "1"
 indexmap = "2"
+# Fast integer→decimal for the JSON.stringify number fast-path (already in the workspace lock).
+itoa = "1"
 fancy-regex = { version = "0.17.0", optional = true }
 # Only under `send-values` (the Arc<Mutex> path): parking_lot's uncontended lock is a
 # single atomic with no pthread syscall — profiled as a top cost on object/array access.

package/crates/tish_core/src/json.rs

@@ -3,13 +3,70 @@
 use crate::{Value, VmRef};
 use std::sync::Arc;
 
+/// Per-`json_parse`-call cache of object-key text → shared `Arc<str>`. A JSON array of records
+/// repeats the same handful of keys across thousands of objects; interning allocates each key
+/// once and `Arc::clone`s it thereafter, instead of a fresh `Arc<str>` allocation per occurrence.
+type KeyCache = ahash::AHashMap<Box<str>, Arc<str>>;
+
+#[inline]
+fn intern_key(cache: &mut KeyCache, s: &str) -> Arc<str> {
+    if let Some(existing) = cache.get(s) {
+        return Arc::clone(existing);
+    }
+    let arc: Arc<str> = Arc::from(s);
+    cache.insert(Box::from(s), Arc::clone(&arc));
+    arc
+}
+
+/// Append `n` to `buf` exactly as JS `JSON.stringify` formats a number. Integer-valued finite
+/// numbers within the safe-integer range (`|n| < 2^53`) take a fast `i64` path — bit-identical to
+/// JS for every such value (verified against Node over 100k values) and far cheaper than the `f64`
+/// formatter. Everything else uses the ECMAScript `Number::toString` (`js_number_to_string`),
+/// which matches JS where Rust's `{}` Display would not (e.g. `1e21`, `1e-7`). NaN/∞ → `null`.
+/// Public so the interpreter's separate JSON path formats numbers identically (single source of
+/// truth → interp/vm/native/node agree).
+#[inline]
+pub fn write_json_number(buf: &mut String, n: f64) {
+    if n.is_nan() || n.is_infinite() {
+        buf.push_str("null");
+        return;
+    }
+    if n.fract() == 0.0 && n.abs() < 9_007_199_254_740_992.0 {
+        let mut b = itoa::Buffer::new();
+        buf.push_str(b.format(n as i64));
+        return;
+    }
+    crate::js_number_to_string_into(buf, n);
+}
+
+/// Scan a string body (the input with its opening `"` already removed) for the closing quote.
+/// Returns `Ok(Some((body, rest)))` when the string is escape-free — `body` is the raw contents and
+/// `rest` is the input just past the closing quote, so the value is built in a single allocation
+/// with no per-char decode. Returns `Ok(None)` on the first backslash (caller uses the escape
+/// decoder) and `Err` if unterminated. Only stops on the ASCII bytes `"`/`\\`, so the byte index
+/// always lands on a UTF-8 char boundary — multi-byte sequences pass through inside `body` intact.
+#[inline]
+fn scan_escape_free(body: &str) -> Result<Option<(&str, &str)>, String> {
+    let bytes = body.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\\' => return Ok(None),
+            b'"' => return Ok(Some((&body[..i], &body[i + 1..]))),
+            _ => i += 1,
+        }
+    }
+    Err("Unterminated string".to_string())
+}
+
 /// Parse JSON string into a Value.
 pub fn json_parse(json: &str) -> Result<Value, String> {
     let json = json.trim();
     if json.is_empty() {
         return Err("SyntaxError: Unexpected end of JSON input".to_string());
     }
-    let (value, rest) = parse_value(json, 0)?;
+    let mut cache = KeyCache::default();
+    let (value, rest) = parse_value(json, 0, &mut cache)?;
     if !rest.trim().is_empty() {
         return Err("SyntaxError: Unexpected token at end of JSON".to_string());
     }
@@ -39,17 +96,7 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
         Value::Null => buf.push_str("null"),
         Value::Bool(true) => buf.push_str("true"),
         Value::Bool(false) => buf.push_str("false"),
-        Value::Number(n) => {
-            if n.is_nan() || n.is_infinite() {
-                buf.push_str("null");
-            } else {
-                // `write!` avoids the heap allocation that `to_string`
-                // produces. The f64 → decimal formatter is the same
-                // either way (`std::fmt::Display`).
-                use std::fmt::Write;
-                let _ = write!(buf, "{}", n);
-            }
-        }
+        Value::Number(n) => write_json_number(buf, *n),
         Value::String(s) => {
             buf.push('"');
             escape_json_string_into(buf, s);
@@ -69,16 +116,11 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
         Value::NumberArray(arr) => {
             let borrowed = arr.borrow();
             buf.push('[');
-            use std::fmt::Write;
             for (i, n) in borrowed.iter().enumerate() {
                 if i > 0 {
                     buf.push(',');
                 }
-                if n.is_nan() || n.is_infinite() {
-                    buf.push_str("null");
-                } else {
-                    let _ = write!(buf, "{}", n);
-                }
+                write_json_number(buf, *n);
             }
             buf.push(']');
         }
@@ -153,7 +195,11 @@ fn escape_json_string_into(buf: &mut String, s: &str) {
 /// whole process (uncatchable, SIGABRT). 128 matches serde_json's default limit.
 const MAX_JSON_DEPTH: usize = 128;
 
-fn parse_value(input: &str, depth: usize) -> Result<(Value, &str), String> {
+fn parse_value<'a>(
+    input: &'a str,
+    depth: usize,
+    cache: &mut KeyCache,
+) -> Result<(Value, &'a str), String> {
     let input = input.trim_start();
     if input.is_empty() {
         return Err("Unexpected end of JSON input".to_string());
@@ -163,8 +209,8 @@ fn parse_value(input: &str, depth: usize) -> Result<(Value, &str), String> {
         'n' => parse_null(input),
         't' | 'f' => parse_bool(input),
         '"' => parse_string(input),
-        '[' => parse_array(input, depth),
-        '{' => parse_object(input, depth),
+        '[' => parse_array(input, depth, cache),
+        '{' => parse_object(input, depth, cache),
         c if c == '-' || c.is_ascii_digit() => parse_number(input),
         c => Err(format!("Unexpected character '{}' in JSON", c)),
     }
@@ -189,6 +235,31 @@ fn parse_bool(input: &str) -> Result<(Value, &str), String> {
 }
 
 fn parse_string(input: &str) -> Result<(Value, &str), String> {
+    // Fast path: an escape-free string is a direct slice of the input — one allocation, no decode.
+    let body = &input[1..]; // skip opening quote (ASCII, safe byte index)
+    if let Some((s, rest)) = scan_escape_free(body)? {
+        return Ok((Value::String(s.into()), rest));
+    }
+    parse_string_escaped(input)
+}
+
+/// Read an object key, interning it through `cache` so repeated keys share one `Arc<str>` instead
+/// of allocating a fresh one per occurrence. Escape-free keys (the common case) look up the cache
+/// with the borrowed slice — zero allocations on a hit.
+fn parse_key<'a>(input: &'a str, cache: &mut KeyCache) -> Result<(Arc<str>, &'a str), String> {
+    let body = &input[1..];
+    if let Some((s, rest)) = scan_escape_free(body)? {
+        return Ok((intern_key(cache, s), rest));
+    }
+    let (val, rest) = parse_string_escaped(input)?;
+    match val {
+        Value::String(s) => Ok((intern_key(cache, s.as_str()), rest)),
+        _ => unreachable!("parse_string_escaped always yields Value::String"),
+    }
+}
+
+/// Decode a JSON string that contains at least one escape (the slow path).
+fn parse_string_escaped(input: &str) -> Result<(Value, &str), String> {
     let input = &input[1..]; // skip opening quote
     let mut result = String::new();
     let mut chars = input.chars().peekable();
@@ -267,19 +338,25 @@ fn parse_number(input: &str) -> Result<(Value, &str), String> {
     let bytes = input.as_bytes();
     let mut end = 0;
 
-    if bytes.first() == Some(&b'-') {
+    let neg = bytes.first() == Some(&b'-');
+    if neg {
         end += 1;
     }
+    let int_start = end;
     while end < bytes.len() && bytes[end].is_ascii_digit() {
         end += 1;
     }
+    let int_len = end - int_start;
+    let mut is_integer = true;
     if bytes.get(end) == Some(&b'.') {
+        is_integer = false;
         end += 1;
         while end < bytes.len() && bytes[end].is_ascii_digit() {
             end += 1;
         }
     }
     if matches!(bytes.get(end), Some(&b'e') | Some(&b'E')) {
+        is_integer = false;
         end += 1;
         if matches!(bytes.get(end), Some(&b'+') | Some(&b'-')) {
             end += 1;
@@ -291,13 +368,27 @@ fn parse_number(input: &str) -> Result<(Value, &str), String> {
 
     // `end` lands on an ASCII boundary, so slicing `input` by byte index is valid.
     let num_str = &input[..end];
+    // Integer fast-path: a pure integer of ≤15 digits fits `i64` and is exact in `f64`
+    // (|value| < 10^15 < 2^53), so `i64 as f64` equals the full float parse but is far cheaper —
+    // and JSON arrays of records are integer-heavy. Negative zero is excluded: `i64` loses the
+    // sign, but `JSON.parse("-0")` must yield `-0.0` (matches std `f64` parse and Node).
+    if is_integer && (1..=15).contains(&int_len) {
+        if let Ok(i) = num_str.parse::<i64>() {
+            let n = if neg && i == 0 { -0.0 } else { i as f64 };
+            return Ok((Value::Number(n), &input[end..]));
+        }
+    }
     num_str
         .parse::<f64>()
         .map(|n| (Value::Number(n), &input[end..]))
         .map_err(|_| format!("Invalid number: {}", num_str))
 }
 
-fn parse_array(input: &str, depth: usize) -> Result<(Value, &str), String> {
+fn parse_array<'a>(
+    input: &'a str,
+    depth: usize,
+    cache: &mut KeyCache,
+) -> Result<(Value, &'a str), String> {
     if depth >= MAX_JSON_DEPTH {
         return Err("JSON nesting too deep".to_string());
     }
@@ -310,7 +401,7 @@ fn parse_array(input: &str, depth: usize) -> Result<(Value, &str), String> {
     }
 
     loop {
-        let (value, rest) = parse_value(input, depth + 1)?;
+        let (value, rest) = parse_value(input, depth + 1, cache)?;
         items.push(value);
         input = rest.trim_start();
 
@@ -322,17 +413,28 @@ fn parse_array(input: &str, depth: usize) -> Result<(Value, &str), String> {
     }
 }
 
-fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
+fn parse_object<'a>(
+    input: &'a str,
+    depth: usize,
+    cache: &mut KeyCache,
+) -> Result<(Value, &'a str), String> {
     if depth >= MAX_JSON_DEPTH {
         return Err("JSON nesting too deep".to_string());
     }
     let mut input = &input[1..]; // skip '{'
-    let mut map = crate::ObjectMap::default();
+    // Build the insertion-ordered `PropMap` directly. The old path collected into an `AHashMap`
+    // and then re-inserted every pair into a `PropMap` via `from_strings` — a wasted map + rehash
+    // per object, AND the `AHashMap` iteration order scrambled JSON key order (its `RandomState`
+    // reseeds per process), so `Object.keys` after `JSON.parse` came out in a non-spec order.
+    let mut map = crate::PropMap::new();
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix('}') {
         return Ok((
-            Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+            Value::Object(VmRef::new(crate::ObjectData {
+                strings: map,
+                symbols: None,
+            })),
             rest,
         ));
     }
@@ -343,11 +445,7 @@ fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
             return Err("Expected string key in object".to_string());
         }
 
-        let (key_val, rest) = parse_string(input)?;
-        let key: Arc<str> = match key_val {
-            Value::String(s) => Arc::from(s.as_str()),
-            _ => unreachable!(),
-        };
+        let (key, rest) = parse_key(input, cache)?;
 
         input = rest.trim_start();
         if !input.starts_with(':') {
@@ -355,7 +453,7 @@ fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
         }
         input = &input[1..];
 
-        let (value, rest) = parse_value(input, depth + 1)?;
+        let (value, rest) = parse_value(input, depth + 1, cache)?;
         map.insert(key, value);
         input = rest.trim_start();
 
@@ -363,7 +461,10 @@ fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
             Some(',') => input = &input[1..],
             Some('}') => {
                 return Ok((
-                    Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+                    Value::Object(VmRef::new(crate::ObjectData {
+                        strings: map,
+                        symbols: None,
+                    })),
                     &input[1..],
                 ));
             }

package/crates/tish_core/src/lib.rs

@@ -12,9 +12,31 @@ mod value;
 mod vmref;
 
 pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
-pub use json::{json_parse, json_stringify, json_stringify_into};
+pub use json::{json_parse, json_stringify, json_stringify_into, write_json_number};
 pub use shape::{ShapeId, DICT_SHAPE, EMPTY_SHAPE};
 pub use uri::{percent_decode, percent_encode};
 pub use arcstr::ArcStr;
 pub use value::*;
 pub use vmref::{VmReadGuard, VmRef, VmWriteGuard};
+
+/// `process.argv` for the interpreter / VM. Defaults to the host process's own `std::env::args()`,
+/// but `tish run <file> [args...]` overrides it (via [`set_process_argv`]) with a node-shaped argv
+/// `[tish-exe, <file>, args...]` so a script sees its own args — not the `run` subcommand. Compiled
+/// native binaries don't touch this; they read `std::env::args()` directly (which is already their
+/// own argv). #88
+static PROCESS_ARGV: std::sync::OnceLock<Vec<String>> = std::sync::OnceLock::new();
+
+/// Override `process.argv` for the interpreter/VM (set once by `tish run` before executing). A
+/// later call is ignored (the first override wins), matching the single-program-per-process model.
+pub fn set_process_argv(argv: Vec<String>) {
+    let _ = PROCESS_ARGV.set(argv);
+}
+
+/// The argv a script should see as `process.argv`: the [`set_process_argv`] override if present,
+/// else the host process's `std::env::args()`.
+pub fn process_argv() -> Vec<String> {
+    match PROCESS_ARGV.get() {
+        Some(v) => v.clone(),
+        None => std::env::args().collect(),
+    }
+}