@tishlang/tish 2.2.7 → 2.8.0

package/crates/tish_compile/src/infer.rs

@@ -558,7 +558,7 @@ pub(crate) fn pi_mentions(e: &Expr, name: &str) -> bool {
             }
         }),
         Object { props, .. } => props.iter().any(|p| match p {
-            tishlang_ast::ObjectProp::KeyValue(_, v) => pi_mentions(v, name),
+            tishlang_ast::ObjectProp::KeyValue(_, v, _) => pi_mentions(v, name),
             tishlang_ast::ObjectProp::Spread(x) => pi_mentions(x, name),
         }),
         TemplateLiteral { exprs, .. } => exprs.iter().any(|x| pi_mentions(x, name)),
@@ -634,7 +634,7 @@ fn infer_object_shape(
     let mut fields = Vec::with_capacity(props.len());
     for p in props {
         match p {
-            tishlang_ast::ObjectProp::KeyValue(k, v) => {
+            tishlang_ast::ObjectProp::KeyValue(k, v, _) => {
                 let ty = infer_expr_type(v, ctx)?;
                 // Only primitive field types in this conservative version.
                 if !matches!(&ty, TypeAnnotation::Simple(s, _)
@@ -1303,7 +1303,7 @@ fn arr_expr_safe(e: &Expr, name: &str) -> bool {
             }
         }),
         Object { props, .. } => props.iter().all(|p| match p {
-            tishlang_ast::ObjectProp::KeyValue(_, v) => arr_expr_safe(v, name),
+            tishlang_ast::ObjectProp::KeyValue(_, v, _) => arr_expr_safe(v, name),
             tishlang_ast::ObjectProp::Spread(v) => arr_expr_safe(v, name),
         }),
         // Anything else that mentions `name`: be safe, bail.
@@ -1423,7 +1423,7 @@ fn expr_name_safe(e: &Expr, name: &str, keys: &std::collections::HashSet<&str>)
             }
         }),
         Object { props, .. } => props.iter().all(|p| match p {
-            tishlang_ast::ObjectProp::KeyValue(_, v) => expr_name_safe(v, name, keys),
+            tishlang_ast::ObjectProp::KeyValue(_, v, _) => expr_name_safe(v, name, keys),
             tishlang_ast::ObjectProp::Spread(e) => expr_name_safe(e, name, keys),
         }),
         TemplateLiteral { exprs, .. } => exprs.iter().all(|e| expr_name_safe(e, name, keys)),

package/crates/tish_compile/src/lib.rs

@@ -186,6 +186,44 @@ fn factory() {
             "expected outerVar to be inferred as f64 (Copy, no clone needed)"
         );
     }
+
+    /// i32-loop-var lowering: an FNV-style integer/bitwise hash accumulator declared before a `for`
+    /// and reassigned only by `>>> 0`/bitwise ops lives in an `i32` register across the loop — no
+    /// per-op `to_int32(h)`↔`f64` round-trip — with a single `f64` excursion for the `h * C`
+    /// multiply (which exceeds 2^53, so it must round in f64 before `>>> 0`, exactly as V8 does).
+    #[test]
+    fn fnv_accumulator_lowers_to_i32_register() {
+        let src = r#"
+let h = 2166136261
+for (let i = 0; i < 100; i++) {
+  h = h ^ (i & 255)
+  h = (h * 16777619) >>> 0
+  h = ((h << 13) | (h >>> 19)) >>> 0
+}
+let check = h >>> 0
+console.log(check)
+"#;
+        let rust = compile(&parse(src).unwrap()).unwrap();
+        // The accumulator is an i32 register, initialized via the u32 reinterpretation so the
+        // > i32::MAX seed keeps its JS ToInt32 bit-pattern.
+        assert!(
+            rust.contains("let mut h: i32 = (2166136261u32) as i32;"),
+            "expected `h` to be an i32 register seeded via u32 reinterpretation; got:\n{}",
+            rust.lines().filter(|l| l.contains("h")).take(8).collect::<Vec<_>>().join("\n")
+        );
+        // The per-iteration `to_int32(h)` round-trips are gone: `h` is read straight from the
+        // register inside the bitwise chain (no `to_int32(h)` substring referencing the accumulator).
+        assert!(
+            !rust.contains("to_int32(h)"),
+            "expected NO per-op `to_int32(h)` round-trip on the i32 accumulator"
+        );
+        // The only f64 excursion is the multiply, lowered as an unchecked truncation of the
+        // provably-finite product (`h as f64 * 16777619`).
+        assert!(
+            rust.contains(".to_int_unchecked::<i64>()") && rust.contains("16777619"),
+            "expected the `h * 16777619` excursion to lower to an unchecked f64 truncation"
+        );
+    }
 }
 
 #[cfg(test)]

package/crates/tish_compile/src/resolve.rs

@@ -173,7 +173,7 @@ pub fn program_uses_document(program: &Program) -> bool {
                 ArrayElement::Expr(e) | ArrayElement::Spread(e) => expr_uses_document(e),
             }),
             Expr::Object { props, .. } => props.iter().any(|p| match p {
-                ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => expr_uses_document(e),
+                ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => expr_uses_document(e),
             }),
             Expr::Assign { value, .. }
             | Expr::CompoundAssign { value, .. }
@@ -1601,7 +1601,7 @@ fn rewrite_expr_scope(expr: &mut Expr, active: &HashMap<String, Arc<str>>) {
         Expr::Object { props, .. } => {
             for p in props {
                 match p {
-                    ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => {
+                    ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => {
                         rewrite_expr_scope(e, active) // key is a property name; value recurses
                     }
                 }
@@ -1819,6 +1819,7 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                                             name: Arc::from(v.clone()),
                                             span: *span,
                                         },
+                                        *name_span,
                                     ));
                                 }
                                 merge_push(

package/crates/tish_compile/src/types.rs

@@ -13,6 +13,12 @@ pub enum RustType {
     Value,
     /// f64 (for number)
     F64,
+    /// i32 — a `number` local PROVEN to always hold an integer reinterpretable as a JS ToInt32
+    /// bit-pattern, kept in an integer register across a bitwise/hash hot loop (bun/JSC-style)
+    /// instead of round-tripping `f64`↔`i32` on every op. The value is the signed int32
+    /// (= JS `ToInt32`) view; `>>> 0` results are uint32 reinterpreted into this i32. Only the
+    /// codegen's i32-loop-var lowering produces this type — never `from_annotation`.
+    I32,
     /// String (for string)
     String,
     /// bool (for boolean)
@@ -222,6 +228,7 @@ impl RustType {
         match self {
             RustType::Value => "Value".to_string(),
             RustType::F64 => "f64".to_string(),
+            RustType::I32 => "i32".to_string(),
             RustType::String => "String".to_string(),
             RustType::Bool => "bool".to_string(),
             RustType::Unit => "()".to_string(),
@@ -250,6 +257,7 @@ impl RustType {
         match self {
             RustType::Value => "Value::Null".to_string(),
             RustType::F64 => "0.0".to_string(),
+            RustType::I32 => "0i32".to_string(),
             RustType::String => "String::new()".to_string(),
             RustType::Bool => "false".to_string(),
             RustType::Unit => "()".to_string(),
@@ -306,6 +314,12 @@ impl RustType {
                 "match &{} {{ Value::Number(n) => *n, _ => panic!(\"expected number\") }}",
                 value_expr
             ),
+            // A `Value::Number` narrowed to its JS ToInt32 bit-pattern (NaN/±Inf → 0, exactly as
+            // the bitwise/shift path coerces). Only reached for an `I32`-typed binding boundary.
+            RustType::I32 => format!(
+                "match &{} {{ Value::Number(n) => tishlang_runtime::to_int32(*n), _ => panic!(\"expected number\") }}",
+                value_expr
+            ),
             RustType::String => format!(
                 "match &{} {{ Value::String(s) => s.to_string(), _ => panic!(\"expected string\") }}",
                 value_expr
@@ -363,6 +377,9 @@ impl RustType {
             }
             RustType::Value => native_expr.to_string(),
             RustType::F64 => format!("Value::Number({})", native_expr),
+            // The signed int32 view boxes as a JS Number (every i32 is exactly representable in
+            // f64). The uint32 `>>> 0` reinterpretation is applied at the boxing site, not here.
+            RustType::I32 => format!("Value::Number(({}) as f64)", native_expr),
             RustType::String => format!("Value::String({}.clone().into())", native_expr),
             RustType::Bool => format!("Value::Bool({})", native_expr),
             RustType::Unit => "Value::Null".to_string(),

package/crates/tish_compile_js/src/codegen.rs

@@ -487,9 +487,29 @@ impl Codegen {
         }
     }
 
+    /// Is `expr` the `null` literal? Used to lower `x === null` / `x !== null` to JS `== null` /
+    /// `!= null` so the check catches `undefined` too (tish treats a missing/undefined value as
+    /// null on every other backend) — see the StrictEq/StrictNe arms below.
+    fn is_null_literal(expr: &Expr) -> bool {
+        matches!(
+            expr,
+            Expr::Literal {
+                value: Literal::Null,
+                ..
+            }
+        )
+    }
+
     fn emit_expr(&mut self, expr: &Expr) -> Result<String, CompileError> {
         Ok(match expr {
             Expr::Literal { value, .. } => match value {
+                // Rust's `{}` prints non-finite f64 as `inf` / `-inf` / `NaN`; only `NaN` is valid JS.
+                // Emit the JS spellings so a folded `1/0` / `-1/0` doesn't become an undefined `inf`
+                // identifier in the output.
+                Literal::Number(n) if n.is_nan() => "NaN".to_string(),
+                Literal::Number(n) if n.is_infinite() => {
+                    if *n < 0.0 { "-Infinity".to_string() } else { "Infinity".to_string() }
+                }
                 Literal::Number(n) => format!("{}", n),
                 Literal::String(s) => format!("{:?}", s.as_ref()),
                 Literal::Bool(b) => format!("{}", b),
@@ -510,8 +530,26 @@ impl Codegen {
                     BinOp::Pow => "**",
                     BinOp::Eq => "==",
                     BinOp::Ne => "!=",
-                    BinOp::StrictEq => "===",
-                    BinOp::StrictNe => "!==",
+                    // tish has no `undefined`: a missing/absent value reads back as `null`, so
+                    // `x === null` means "is nullish" — exactly how interp/vm/native behave (a
+                    // missing property is null there). In the JS runtime a missing property is
+                    // `undefined`, so lower `=== null` / `!== null` to loose `== null` / `!= null`,
+                    // which match BOTH null and undefined — keeping `=== null` mean the same thing on
+                    // every target. Strict equality between non-null operands is unaffected.
+                    BinOp::StrictEq => {
+                        if Self::is_null_literal(left) || Self::is_null_literal(right) {
+                            "=="
+                        } else {
+                            "==="
+                        }
+                    }
+                    BinOp::StrictNe => {
+                        if Self::is_null_literal(left) || Self::is_null_literal(right) {
+                            "!="
+                        } else {
+                            "!=="
+                        }
+                    }
                     BinOp::Lt => "<",
                     BinOp::Le => "<=",
                     BinOp::Gt => ">",
@@ -563,6 +601,15 @@ impl Codegen {
                 ..
             } => {
                 let obj = self.emit_expr(object)?;
+                // `255.toString()` is a JS syntax error — the lexer reads `255.` as a float and
+                // then chokes on the method name. Parenthesize a numeric-literal object so member
+                // access / method calls stay valid: `(255).toString()`. (Folded constants reach
+                // codegen as number literals too, so this covers e.g. `(100 * 2).toString()`.)
+                let obj = if matches!(&**object, Expr::Literal { value: Literal::Number(_), .. }) {
+                    format!("({})", obj)
+                } else {
+                    obj
+                };
                 let expr = match prop {
                     MemberProp::Name { name, .. } => {
                         if name.parse::<u32>().is_ok()
@@ -629,7 +676,7 @@ impl Codegen {
                 let parts: Result<Vec<_>, _> = props
                     .iter()
                     .map(|p| match p {
-                        ObjectProp::KeyValue(k, v) => {
+                        ObjectProp::KeyValue(k, v, _) => {
                             let key = k.as_ref();
                             let val = self.emit_expr(v)?;
                             Ok(if key.chars().all(|c| c.is_alphanumeric() || c == '_') {
@@ -650,7 +697,11 @@ impl Codegen {
             }
             Expr::TypeOf { operand, .. } => {
                 let o = self.emit_expr(operand)?;
-                format!("(typeof {})", o)
+                // tish `typeof null` is "null" (interp/vm/native all agree — null is a first-class
+                // type, not JS's `typeof null === "object"` wart). tish has no `undefined`, so any
+                // nullish operand (incl. a JS-runtime `undefined`) maps to "null". Evaluate the
+                // operand once via the arrow arg so side effects don't run twice.
+                format!("((__v) => __v == null ? \"null\" : typeof __v)({})", o)
             }
             Expr::Delete { target, .. } => {
                 // Emit the raw property *reference*, not a value: `emit_expr` wraps Index /

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -411,4 +411,48 @@ 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}");
+    }
 }

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(),
+    }
+}