@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_compile_js/src/lib.rs

@@ -7,7 +7,9 @@ mod error;
 #[cfg(test)]
 mod tests_jsx;
 
-pub use codegen::{compile_project_with_jsx, compile_with_jsx};
+pub use codegen::{
+    compile_project_with_jsx, compile_project_with_jsx_and_source_map, compile_with_jsx, JsBundle,
+};
 pub use error::CompileError;
 
 /// JSX lowers to `h` / `Fragment`; merge the `lattish` runtime for hooks and DOM.

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -11,7 +11,11 @@ mod tests {
         let src = r#"fn X() { return <div class="a">{"hi"}</div> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"), "{}", js);
+        assert!(
+            js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"),
+            "{}",
+            js
+        );
         assert!(!js.contains("function __h("));
     }
 
@@ -57,7 +61,11 @@ mod tests {
         let src = r#"fn X() { return <p>work!</p> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains(r#""work!""#), "expected 'work!', got: {}", &js[..400.min(js.len())]);
+        assert!(
+            js.contains(r#""work!""#),
+            "expected 'work!', got: {}",
+            &js[..400.min(js.len())]
+        );
     }
 
     #[test]
@@ -65,7 +73,11 @@ mod tests {
         let src = r#"fn X() { return <p>hello 😔</p> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("😔"), "expected emoji, got: {}", &js[..400.min(js.len())]);
+        assert!(
+            js.contains("😔"),
+            "expected emoji, got: {}",
+            &js[..400.min(js.len())]
+        );
     }
 
     #[test]
@@ -93,10 +105,22 @@ mod tests {
         let src = r#"fn X() { return <div class="x">{"a"}</div> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("h(\"div\", { class: \"x\" }"), "{}", &js[..500.min(js.len())]);
+        assert!(
+            js.contains("h(\"div\", { class: \"x\" }"),
+            "{}",
+            &js[..500.min(js.len())]
+        );
         assert!(!js.contains("__vdom_h"), "{}", &js[..600.min(js.len())]);
-        assert!(!js.contains("window.__LATTISH_JSX_VDOM"), "{}", &js[..600.min(js.len())]);
-        assert!(!js.contains("__lattishVdomPatch"), "{}", &js[..600.min(js.len())]);
+        assert!(
+            !js.contains("window.__LATTISH_JSX_VDOM"),
+            "{}",
+            &js[..600.min(js.len())]
+        );
+        assert!(
+            !js.contains("__lattishVdomPatch"),
+            "{}",
+            &js[..600.min(js.len())]
+        );
     }
 
     /// Component calls like {Panel()} return DOM elements. Wrapping in String() produces [object HTMLDivElement].

package/crates/tish_compiler_wasm/src/lib.rs

@@ -14,29 +14,34 @@ use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub fn compile_to_bytecode(source: &str) -> Result<String, JsValue> {
-    let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let program =
+        tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
     let program = tishlang_opt::optimize(&program);
-    let chunk = tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let chunk =
+        tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
     Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
 }
 
 #[wasm_bindgen]
 pub fn compile_to_js(source: &str) -> Result<String, JsValue> {
-    let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    tishlang_compile_js::compile_with_jsx(&program, true)
-        .map_err(|e| JsValue::from_str(&e.message))
+    let program =
+        tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    tishlang_compile_js::compile_with_jsx(&program, true).map_err(|e| JsValue::from_str(&e.message))
 }
 
 #[wasm_bindgen]
-pub fn compile_to_bytecode_with_imports(entry_path: &str, files_json: &str) -> Result<String, JsValue> {
+pub fn compile_to_bytecode_with_imports(
+    entry_path: &str,
+    files_json: &str,
+) -> Result<String, JsValue> {
     let files: HashMap<String, String> = serde_json::from_str(files_json)
         .map_err(|e| JsValue::from_str(&format!("Invalid files JSON: {}", e)))?;
-    let modules = resolve_virtual(entry_path, &files)
-        .map_err(|e| JsValue::from_str(&e))?;
+    let modules = resolve_virtual(entry_path, &files).map_err(|e| JsValue::from_str(&e))?;
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
     let program = tishlang_opt::optimize(&program);
-    let chunk = tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let chunk =
+        tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
     Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
 }
 
@@ -44,11 +49,9 @@ pub fn compile_to_bytecode_with_imports(entry_path: &str, files_json: &str) -> R
 pub fn compile_to_js_with_imports(entry_path: &str, files_json: &str) -> Result<String, JsValue> {
     let files: HashMap<String, String> = serde_json::from_str(files_json)
         .map_err(|e| JsValue::from_str(&format!("Invalid files JSON: {}", e)))?;
-    let modules = resolve_virtual(entry_path, &files)
-        .map_err(|e| JsValue::from_str(&e))?;
+    let modules = resolve_virtual(entry_path, &files).map_err(|e| JsValue::from_str(&e))?;
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
     let program = tishlang_opt::optimize(&program);
-    tishlang_compile_js::compile_with_jsx(&program, true)
-        .map_err(|e| JsValue::from_str(&e.message))
+    tishlang_compile_js::compile_with_jsx(&program, true).map_err(|e| JsValue::from_str(&e.message))
 }

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -17,6 +17,7 @@ pub struct VirtualModule {
 const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("fs", "tish:fs"),
     ("http", "tish:http"),
+    ("timers", "tish:timers"),
     ("process", "tish:process"),
     ("ws", "tish:ws"),
 ];
@@ -35,7 +36,7 @@ fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
         || spec.starts_with('@')
-        || matches!(spec, "fs" | "http" | "process" | "ws")
+        || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
 }
 
 /// Normalize a virtual path: resolve . and .. components.
@@ -109,10 +110,16 @@ pub fn resolve_virtual(
         if files.contains_key(&with_ext) {
             with_ext
         } else {
-            return Err(format!("Entry file '{}' not in virtual file map", entry_path));
+            return Err(format!(
+                "Entry file '{}' not in virtual file map",
+                entry_path
+            ));
         }
     } else {
-        return Err(format!("Entry file '{}' not in virtual file map", entry_path));
+        return Err(format!(
+            "Entry file '{}' not in virtual file map",
+            entry_path
+        ));
     };
 
     let mut visited = HashSet::new();
@@ -148,9 +155,9 @@ fn load_module_recursive(
     }
     visited.insert(module_path.to_string());
 
-    let source = files.get(module_path).ok_or_else(|| {
-        format!("Module '{}' not in virtual file map", module_path)
-    })?;
+    let source = files
+        .get(module_path)
+        .ok_or_else(|| format!("Module '{}' not in virtual file map", module_path))?;
     let program = tishlang_parser::parse(source.trim())
         .map_err(|e| format!("Parse error in {}: {}", module_path, e))?;
 
@@ -162,13 +169,7 @@ fn load_module_recursive(
             }
             let dep_key = resolve_import_to_key(from, from_dir, files)?;
             if !path_to_module.contains_key(&dep_key) {
-                load_module_recursive(
-                    &dep_key,
-                    files,
-                    visited,
-                    path_to_module,
-                    load_order,
-                )?;
+                load_module_recursive(&dep_key, files, visited, path_to_module, load_order)?;
             }
         }
     }
@@ -197,11 +198,11 @@ pub fn detect_cycles_virtual(modules: &[VirtualModule]) -> Result<(), String> {
             &mut stack,
             &mut HashSet::new(),
         )? {
-            let path_names: Vec<_> = stack
-                .iter()
-                .map(|&i| modules[i].path.clone())
-                .collect();
-            return Err(format!("Circular import detected: {}", path_names.join(" -> ")));
+            let path_names: Vec<_> = stack.iter().map(|&i| modules[i].path.clone()).collect();
+            return Err(format!(
+                "Circular import detected: {}",
+                path_names.join(" -> ")
+            ));
         }
     }
     Ok(())
@@ -231,14 +232,8 @@ fn has_cycle_from(
                     stack.push(dep_idx);
                     let dep = &modules[dep_idx];
                     let dep_dir = parent_dir(&dep.path);
-                    if has_cycle_from(
-                        dep_dir,
-                        &dep.program,
-                        path_to_idx,
-                        modules,
-                        stack,
-                        visiting,
-                    )? {
+                    if has_cycle_from(dep_dir, &dep.program, path_to_idx, modules, stack, visiting)?
+                    {
                         return Ok(true);
                     }
                     stack.pop();
@@ -307,14 +302,24 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
         let dir = parent_dir(&module.path);
         for stmt in &module.program.statements {
             match stmt {
-                Statement::Import { specifiers, from, span } => {
+                Statement::Import {
+                    specifiers,
+                    from,
+                    span,
+                } => {
                     if is_native_import(from) {
                         let canonical_spec =
                             normalize_builtin_spec(from).unwrap_or_else(|| from.to_string());
                         for spec in specifiers {
                             match spec {
-                                ImportSpecifier::Named { name, alias } => {
+                                ImportSpecifier::Named {
+                                    name,
+                                    name_span,
+                                    alias,
+                                    alias_span,
+                                } => {
                                     let bind = alias.as_deref().unwrap_or(name.as_ref());
+                                    let decl_name_span = alias_span.as_ref().unwrap_or(name_span);
                                     let init = Expr::NativeModuleLoad {
                                         spec: Arc::from(canonical_spec.clone()),
                                         export_name: name.clone(),
@@ -322,23 +327,24 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                     };
                                     statements.push(Statement::VarDecl {
                                         name: Arc::from(bind),
+                                        name_span: *decl_name_span,
                                         mutable: false,
                                         type_ann: None,
                                         init: Some(init),
                                         span: *span,
                                     });
                                 }
-                                ImportSpecifier::Namespace(ns) => {
+                                ImportSpecifier::Namespace { name, .. } => {
                                     return Err(format!(
                                         "Namespace import (* as {}) not supported for native module '{}'",
-                                        ns.as_ref(),
+                                        name.as_ref(),
                                         from.as_ref()
                                     ));
                                 }
-                                ImportSpecifier::Default(bind) => {
+                                ImportSpecifier::Default { name, .. } => {
                                     return Err(format!(
                                         "Default import '{}' not supported for native module '{}'. Use named import.",
-                                        bind.as_ref(),
+                                        name.as_ref(),
                                         from.as_ref()
                                     ));
                                 }
@@ -353,15 +359,22 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                     let dep_exports = &module_exports[dep_idx];
                     for spec in specifiers {
                         match spec {
-                            ImportSpecifier::Named { name, alias } => {
+                            ImportSpecifier::Named {
+                                name,
+                                name_span,
+                                alias,
+                                alias_span,
+                            } => {
                                 let source = dep_exports
                                     .get(name.as_ref())
                                     .cloned()
                                     .unwrap_or_else(|| name.to_string());
                                 let bind = alias.as_deref().unwrap_or(name.as_ref());
                                 if bind != source {
+                                    let decl_name_span = alias_span.as_ref().unwrap_or(name_span);
                                     statements.push(Statement::VarDecl {
                                         name: Arc::from(bind),
+                                        name_span: *decl_name_span,
                                         mutable: false,
                                         type_ann: None,
                                         init: Some(Expr::Ident {
@@ -372,7 +385,7 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                     });
                                 }
                             }
-                            ImportSpecifier::Namespace(ns) => {
+                            ImportSpecifier::Namespace { name, name_span } => {
                                 let mut props = Vec::new();
                                 for (k, v) in dep_exports {
                                     props.push(tishlang_ast::ObjectProp::KeyValue(
@@ -384,25 +397,22 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                     ));
                                 }
                                 statements.push(Statement::VarDecl {
-                                    name: ns.clone(),
+                                    name: name.clone(),
+                                    name_span: *name_span,
                                     mutable: false,
                                     type_ann: None,
-                                    init: Some(Expr::Object {
-                                        props,
-                                        span: *span,
-                                    }),
+                                    init: Some(Expr::Object { props, span: *span }),
                                     span: *span,
                                 });
                             }
-                            ImportSpecifier::Default(bind) => {
-                                let source = dep_exports
-                                    .get("default")
-                                    .cloned()
-                                    .ok_or_else(|| {
+                            ImportSpecifier::Default { name, name_span } => {
+                                let source =
+                                    dep_exports.get("default").cloned().ok_or_else(|| {
                                         format!("Module '{}' has no default export", from)
                                     })?;
                                 statements.push(Statement::VarDecl {
-                                    name: bind.clone(),
+                                    name: name.clone(),
+                                    name_span: *name_span,
                                     mutable: false,
                                     type_ann: None,
                                     init: Some(Expr::Ident {
@@ -415,21 +425,21 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                         }
                     }
                 }
-                Statement::Export { declaration, .. } => {
-                    match declaration.as_ref() {
-                        ExportDeclaration::Named(s) => statements.push(*s.clone()),
-                        ExportDeclaration::Default(e) => {
-                            let default_name = format!("__default_{}", idx);
-                            statements.push(Statement::VarDecl {
-                                name: Arc::from(default_name),
-                                mutable: false,
-                                type_ann: None,
-                                init: Some((*e).clone()),
-                                span: e.span(),
-                            });
-                        }
+                Statement::Export { declaration, .. } => match declaration.as_ref() {
+                    ExportDeclaration::Named(s) => statements.push(*s.clone()),
+                    ExportDeclaration::Default(e) => {
+                        let default_name = format!("__default_{}", idx);
+                        let espan = e.span();
+                        statements.push(Statement::VarDecl {
+                            name: Arc::from(default_name),
+                            name_span: espan,
+                            mutable: false,
+                            type_ann: None,
+                            init: Some((*e).clone()),
+                            span: espan,
+                        });
                     }
-                }
+                },
                 _ => statements.push(stmt.clone()),
             }
         }

package/crates/tish_core/Cargo.toml

@@ -9,6 +9,14 @@ repository = { workspace = true }
 [features]
 default = []
 regex = ["dep:fancy-regex"]
+# Make `Value` (and its array / object / regex payloads) `Send + Sync` by
+# switching the interior `Rc<RefCell<T>>` to `Arc<Mutex<T>>` and the native
+# function type from `Rc<dyn Fn>` to `Arc<dyn Fn + Send + Sync>`. Enabled
+# transitively by any crate that needs to pass `Value`s across threads —
+# most notably `tishlang_runtime/http`, which dispatches HTTP handlers
+# across a worker pool. Off by default so wasm / wasi / cranelift / llvm /
+# interpreter builds pay no atomic-ref-count or mutex overhead.
+send-values = []
 
 [dependencies]
 ahash = "0.8.11"

package/crates/tish_core/src/json.rs

@@ -1,8 +1,6 @@
 //! JSON parsing and stringification for Tish values.
 
-use crate::Value;
-use std::cell::RefCell;
-use std::rc::Rc;
+use crate::{Value, VmRef};
 use std::sync::Arc;
 
 /// Parse JSON string into a Value.
@@ -19,75 +17,126 @@ pub fn json_parse(json: &str) -> Result<Value, String> {
 }
 
 /// Stringify a Value to JSON.
+///
+/// Single-buffer write strategy: all nested values append into one
+/// `String` via [`json_stringify_into`], so we never allocate a transient
+/// per-node `String` only to copy + drop it on the way back up. For a
+/// 20-row TFB `/queries` response (~40 numbers, 2 keys × 20 = ~80 string
+/// ops) that saves dozens of small allocations per request.
 pub fn json_stringify(value: &Value) -> String {
+    // 256 B is enough for typical TFB responses (`/db` is 31 B,
+    // `/queries=20` is ~700 B). Larger payloads reallocate normally.
+    let mut buf = String::with_capacity(256);
+    json_stringify_into(&mut buf, value);
+    buf
+}
+
+/// Append a JSON-stringified `value` to `buf`. Used by JSON.stringify for
+/// the recursive case so we don't pay for an intermediate `String` per
+/// node.
+pub fn json_stringify_into(buf: &mut String, value: &Value) {
     match value {
-        Value::Null => "null".to_string(),
-        Value::Bool(b) => b.to_string(),
+        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() {
-                "null".to_string()
+                buf.push_str("null");
             } else {
-                n.to_string()
+                // `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::String(s) => format!("\"{}\"", escape_json_string(s)),
+        Value::String(s) => {
+            buf.push('"');
+            escape_json_string_into(buf, s);
+            buf.push('"');
+        }
         Value::Array(arr) => {
             let borrowed = arr.borrow();
-            let mut result = String::with_capacity(borrowed.len() * 8 + 2);
-            result.push('[');
-            let mut first = true;
-            for item in borrowed.iter() {
-                if !first {
-                    result.push(',');
+            buf.push('[');
+            for (i, item) in borrowed.iter().enumerate() {
+                if i > 0 {
+                    buf.push(',');
                 }
-                first = false;
-                result.push_str(&json_stringify(item));
+                json_stringify_into(buf, item);
             }
-            result.push(']');
-            result
+            buf.push(']');
         }
         Value::Object(obj) => {
             let borrowed = obj.borrow();
-            let mut keys: Vec<_> = borrowed.keys().collect();
-            keys.sort();
-            let mut result = String::with_capacity(borrowed.len() * 16 + 2);
-            result.push('{');
-            let mut first = true;
-            for key in keys {
-                if !first {
-                    result.push(',');
+            // Sort keys for deterministic output. Pre-allocate to avoid
+            // a fresh `Vec` realloc inside `keys().collect()`.
+            let mut keys: Vec<&Arc<str>> = Vec::with_capacity(borrowed.len());
+            keys.extend(borrowed.keys());
+            keys.sort_unstable_by(|a, b| a.as_ref().cmp(b.as_ref()));
+            buf.push('{');
+            for (i, key) in keys.into_iter().enumerate() {
+                if i > 0 {
+                    buf.push(',');
                 }
-                first = false;
-                result.push('"');
-                result.push_str(&escape_json_string(key));
-                result.push_str("\":");
-                result.push_str(&json_stringify(borrowed.get(key).unwrap()));
+                buf.push('"');
+                escape_json_string_into(buf, key);
+                buf.push_str("\":");
+                json_stringify_into(buf, borrowed.get(key).unwrap());
             }
-            result.push('}');
-            result
+            buf.push('}');
         }
-        Value::Function(_) => "null".to_string(),
-        Value::Promise(_) => "null".to_string(),
-        Value::Opaque(_) => "null".to_string(),
+        Value::Function(_) | Value::Promise(_) | Value::Opaque(_) => buf.push_str("null"),
         #[cfg(feature = "regex")]
-        Value::RegExp(_) => "null".to_string(),
+        Value::RegExp(_) => buf.push_str("null"),
     }
 }
 
-fn escape_json_string(s: &str) -> String {
-    let mut result = String::with_capacity(s.len());
-    for c in s.chars() {
-        match c {
-            '"' => result.push_str("\\\""),
-            '\\' => result.push_str("\\\\"),
-            '\n' => result.push_str("\\n"),
-            '\r' => result.push_str("\\r"),
-            '\t' => result.push_str("\\t"),
-            c if c.is_control() => result.push_str(&format!("\\u{:04x}", c as u32)),
-            c => result.push(c),
+/// Append an escaped JSON string body (without the surrounding quotes)
+/// to `buf`. Optimised for the common case where the input is ASCII and
+/// contains no characters that need escaping — we fast-pass the bytes
+/// straight through, only falling into the per-char path on a hit.
+fn escape_json_string_into(buf: &mut String, s: &str) {
+    let bytes = s.as_bytes();
+    let mut start = 0usize;
+    for (i, &b) in bytes.iter().enumerate() {
+        // Anything < 0x20 is a JSON control char that must be escaped;
+        // 0x22 (`"`) and 0x5C (`\`) also need an explicit escape; bytes
+        // ≥ 0x80 are the start of a multi-byte UTF-8 sequence, which is
+        // valid JSON as-is.
+        if b < 0x20 || b == b'"' || b == b'\\' {
+            // Flush the run of clean bytes before this one in one push.
+            if start < i {
+                // SAFETY: `s` is `&str`, every byte in `start..i` was a
+                // single-byte ASCII char (we only stop on ASCII triggers
+                // below 0x80), so the slice is a valid `&str`.
+                buf.push_str(&s[start..i]);
+            }
+            match b {
+                b'"' => buf.push_str("\\\""),
+                b'\\' => buf.push_str("\\\\"),
+                b'\n' => buf.push_str("\\n"),
+                b'\r' => buf.push_str("\\r"),
+                b'\t' => buf.push_str("\\t"),
+                b'\x08' => buf.push_str("\\b"),
+                b'\x0c' => buf.push_str("\\f"),
+                _ => {
+                    use std::fmt::Write;
+                    let _ = write!(buf, "\\u{:04x}", b as u32);
+                }
+            }
+            start = i + 1;
         }
     }
-    result
+    if start < bytes.len() {
+        buf.push_str(&s[start..]);
+    }
+}
+
+#[allow(dead_code)]
+fn escape_json_string(s: &str) -> String {
+    let mut buf = String::with_capacity(s.len());
+    escape_json_string_into(&mut buf, s);
+    buf
 }
 
 fn parse_value(input: &str) -> Result<(Value, &str), String> {
@@ -228,7 +277,7 @@ fn parse_number(input: &str) -> Result<(Value, &str), String> {
 
     let num_str: String = chars[..end].iter().collect();
     let byte_len: usize = chars[..end].iter().map(|c| c.len_utf8()).sum();
-    
+
     num_str
         .parse::<f64>()
         .map(|n| (Value::Number(n), &input[byte_len..]))
@@ -241,7 +290,7 @@ fn parse_array(input: &str) -> Result<(Value, &str), String> {
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix(']') {
-        return Ok((Value::Array(Rc::new(RefCell::new(items))), rest));
+        return Ok((Value::Array(VmRef::new(items)), rest));
     }
 
     loop {
@@ -251,7 +300,7 @@ fn parse_array(input: &str) -> Result<(Value, &str), String> {
 
         match input.chars().next() {
             Some(',') => input = &input[1..],
-            Some(']') => return Ok((Value::Array(Rc::new(RefCell::new(items))), &input[1..])),
+            Some(']') => return Ok((Value::Array(VmRef::new(items)), &input[1..])),
             _ => return Err("Expected ',' or ']' in array".to_string()),
         }
     }
@@ -263,7 +312,7 @@ fn parse_object(input: &str) -> Result<(Value, &str), String> {
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix('}') {
-        return Ok((Value::Object(Rc::new(RefCell::new(map))), rest));
+        return Ok((Value::Object(VmRef::new(map)), rest));
     }
 
     loop {
@@ -290,7 +339,7 @@ fn parse_object(input: &str) -> Result<(Value, &str), String> {
 
         match input.chars().next() {
             Some(',') => input = &input[1..],
-            Some('}') => return Ok((Value::Object(Rc::new(RefCell::new(map))), &input[1..])),
+            Some('}') => return Ok((Value::Object(VmRef::new(map)), &input[1..])),
             _ => return Err("Expected ',' or '}' in object".to_string()),
         }
     }
@@ -306,7 +355,9 @@ mod tests {
         assert!(matches!(json_parse("true").unwrap(), Value::Bool(true)));
         assert!(matches!(json_parse("false").unwrap(), Value::Bool(false)));
         assert!(matches!(json_parse("42").unwrap(), Value::Number(n) if n == 42.0));
-        assert!(matches!(json_parse("\"hello\"").unwrap(), Value::String(s) if s.as_ref() == "hello"));
+        assert!(
+            matches!(json_parse("\"hello\"").unwrap(), Value::String(s) if s.as_ref() == "hello")
+        );
     }
 
     #[test]
@@ -315,7 +366,7 @@ mod tests {
         let value = json_parse(original).unwrap();
         let stringified = json_stringify(&value);
         let reparsed = json_parse(&stringified).unwrap();
-        
+
         match (&value, &reparsed) {
             (Value::Object(a), Value::Object(b)) => {
                 assert_eq!(a.borrow().len(), b.borrow().len());