@tishlang/tish 1.9.2 → 1.10.0

package/crates/js_to_tish/src/transform/expr.rs

@@ -539,9 +539,10 @@ pub fn convert_params(
         let fp = p;
         {
             let (name, name_span) = match &fp.pattern {
-                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
-                    (b.name.as_str(), crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
-                }
+                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => (
+                    b.name.as_str(),
+                    crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                ),
                 _ => {
                     return Err(ConvertError::new(ConvertErrorKind::Unsupported {
                         what: "destructuring in params".into(),
@@ -565,9 +566,10 @@ pub fn convert_params(
     if rest_param.is_none() {
         if let Some(rest) = &params.rest {
             let (rest_name, rest_name_span) = match &rest.rest.argument {
-                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
-                    (b.name.as_str(), crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
-                }
+                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => (
+                    b.name.as_str(),
+                    crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                ),
                 _ => {
                     return Err(ConvertError::new(ConvertErrorKind::Unsupported {
                         what: "rest param with non-identifier".into(),

package/crates/js_to_tish/src/transform/stmt.rs

@@ -247,9 +247,10 @@ fn convert_for_of_statement(
             if v.declarations.len() == 1 {
                 let d = &v.declarations[0];
                 match &d.id {
-                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
-                        (b.name.as_str(), span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
-                    }
+                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => (
+                        b.name.as_str(),
+                        span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                    ),
                     _ => {
                         return Err(ConvertError::new(ConvertErrorKind::Incompatible {
                             what: "for-of with destructuring".into(),
@@ -368,16 +369,14 @@ fn convert_function_decl(
     span: Span,
 ) -> Result<Statement, ConvertError> {
     let async_ = f.r#async;
-    let name: Arc<str> = f
-        .id
-        .as_ref()
-        .map(|id| Arc::from(id.name.as_str()))
-        .unwrap_or_else(|| Arc::from(""));
-    let name_span = f
-        .id
-        .as_ref()
-        .map(|id| span_util::oxc_span_to_tish(ctx.1, id))
-        .unwrap_or_else(span_util::stub_span);
+    let name: Arc<str> =
+        f.id.as_ref()
+            .map(|id| Arc::from(id.name.as_str()))
+            .unwrap_or_else(|| Arc::from(""));
+    let name_span =
+        f.id.as_ref()
+            .map(|id| span_util::oxc_span_to_tish(ctx.1, id))
+            .unwrap_or_else(span_util::stub_span);
     let (params, rest_param) = expr::convert_params(&f.params, ctx)?;
     let body = match &f.body {
         Some(fb) => {

package/crates/tish/Cargo.toml

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

package/crates/tish/src/cargo_native_registry.rs

@@ -19,7 +19,10 @@ pub(crate) fn register_bytecode_native_modules(vm: &mut tishlang_vm::Vm) {
         Arc::from("query_prepared"),
         Value::native(tishlang_pg::query_prepared),
     );
-    om.insert(Arc::from("query_all"), Value::native(tishlang_pg::query_all));
+    om.insert(
+        Arc::from("query_all"),
+        Value::native(tishlang_pg::query_all),
+    );
     om.insert(Arc::from("migrate"), Value::native(tishlang_pg::migrate));
     om.insert(Arc::from("close"), Value::native(tishlang_pg::close));
     vm.register_native_module("cargo:tish_pg", om);

package/crates/tish/src/main.rs

@@ -4,13 +4,11 @@ mod cargo_native_registry;
 mod cli_help;
 mod repl_completion;
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
 use std::collections::HashSet;
 use std::fs;
 use std::io::{self, IsTerminal, Read, Write};
 use std::path::{Path, PathBuf};
-use std::rc::Rc;
+use tishlang_core::VmRef;
 
 use clap::FromArgMatches;
 use rustyline::{Behavior, ColorMode, CompletionType, Config, Editor};
@@ -516,13 +514,14 @@ fn compile_to_js(
         } else {
             program
         };
-        let js = tishlang_compile_js::compile_with_jsx(&p, optimize).map_err(|e| format!("{}", e))?;
+        let js =
+            tishlang_compile_js::compile_with_jsx(&p, optimize).map_err(|e| format!("{}", e))?;
         (js, None)
     } else if input_path.extension().map(|e| e == "js") == Some(true) {
         let source = fs::read_to_string(input_path).map_err(|e| format!("{}", e))?;
         let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        let js =
-            tishlang_compile_js::compile_with_jsx(&program, optimize).map_err(|e| format!("{}", e))?;
+        let js = tishlang_compile_js::compile_with_jsx(&program, optimize)
+            .map_err(|e| format!("{}", e))?;
         (js, None)
     } else if source_map {
         let bundle = tishlang_compile_js::compile_project_with_jsx_and_source_map(
@@ -545,7 +544,8 @@ fn compile_to_js(
     let mut js_out = js;
     if let Some(map) = &map_json {
         let map_path = out_path.with_extension("js.map");
-        fs::write(&map_path, map).map_err(|e| format!("Cannot write {}: {}", map_path.display(), e))?;
+        fs::write(&map_path, map)
+            .map_err(|e| format!("Cannot write {}: {}", map_path.display(), e))?;
         let map_url = map_path
             .file_name()
             .and_then(|s| s.to_str())
@@ -553,7 +553,8 @@ fn compile_to_js(
         js_out.push_str(&format!("\n//# sourceMappingURL={map_url}\n"));
         println!("Built: {}", map_path.display());
     }
-    fs::write(&out_path, js_out).map_err(|e| format!("Cannot write {}: {}", out_path.display(), e))?;
+    fs::write(&out_path, js_out)
+        .map_err(|e| format!("Cannot write {}: {}", out_path.display(), e))?;
     println!("Built: {}", out_path.display());
     Ok(())
 }
@@ -611,11 +612,13 @@ fn build_file(
                 Some(p)
             }
         });
+        let features = native_build_features_from_cli(cli_features);
         return tishlang_wasm::compile_to_wasi(
             &input_path,
             project_root,
             Path::new(output_path),
             optimize,
+            &features,
         )
         .map_err(|e| e.to_string());
     }

package/crates/tish/tests/integration_test.rs

@@ -5,6 +5,7 @@
 //! - Generate/update expected files: `REGENERATE_EXPECTED=1 cargo test -p tishlangtest_mvp_programs_interpreter`
 //!   then commit the new/updated `tests/core/*.tish.expected` files.
 //! - Compiled outputs are cached under `target/integration_compile_cache/` per backend.
+//!   MVP native tests use `native_many/<hash>/` plus one batched nested Cargo build.
 
 use std::collections::hash_map::DefaultHasher;
 use std::ffi::OsString;
@@ -14,6 +15,7 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 
 use rayon::prelude::*;
+use tishlang_native::compile_many_to_native;
 
 fn workspace_root() -> PathBuf {
     PathBuf::from(env!("CARGO_MANIFEST_DIR"))
@@ -50,6 +52,72 @@ fn integration_compile_cache_dir() -> PathBuf {
     target_dir().join("integration_compile_cache")
 }
 
+/// Match `tish build` with no `--feature`: link every capability compiled into this `tish` binary.
+fn native_build_features_for_integration_test() -> Vec<String> {
+    let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
+        .into_iter()
+        .collect();
+    v.sort();
+    v
+}
+
+fn combined_mvp_native_inputs_hash(paths: &[PathBuf]) -> u64 {
+    let mut h = DefaultHasher::new();
+    let feats = native_build_features_for_integration_test();
+    feats.len().hash(&mut h);
+    for f in &feats {
+        f.hash(&mut h);
+    }
+    paths.len().hash(&mut h);
+    for p in paths {
+        p.file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .hash(&mut h);
+        file_content_hash(p).hash(&mut h);
+    }
+    // Native batch cache must invalidate when the emitter or `value_call` changes — not only
+    // when `.tish` sources change; otherwise CI/rust-cache can keep stale nested binaries.
+    let codegen_rs = workspace_root().join("crates/tish_compile/src/codegen.rs");
+    if codegen_rs.is_file() {
+        file_content_hash(&codegen_rs).hash(&mut h);
+    }
+    let value_rs = workspace_root().join("crates/tish_core/src/value.rs");
+    if value_rs.is_file() {
+        file_content_hash(&value_rs).hash(&mut h);
+    }
+    h.finish()
+}
+
+fn mvp_native_batch_cache_dir(combined: u64) -> PathBuf {
+    integration_compile_cache_dir()
+        .join("native_many")
+        .join(format!("{:016x}", combined))
+}
+
+/// Restores the previous process env when dropped (for `TISH_FAST_NATIVE_BUILD` in batch tests).
+struct EnvVarGuard {
+    key: &'static str,
+    previous: Option<std::ffi::OsString>,
+}
+
+impl EnvVarGuard {
+    fn set(key: &'static str, value: &str) -> Self {
+        let previous = std::env::var_os(key);
+        std::env::set_var(key, value);
+        Self { key, previous }
+    }
+}
+
+impl Drop for EnvVarGuard {
+    fn drop(&mut self) {
+        match &self.previous {
+            None => std::env::remove_var(self.key),
+            Some(v) => std::env::set_var(self.key, v),
+        }
+    }
+}
+
 fn file_content_hash(path: &Path) -> u64 {
     let mut f = std::fs::File::open(path).expect("open file for hash");
     let mut content = Vec::new();
@@ -583,6 +651,7 @@ const MVP_TEST_FILES: &[&str] = &[
     "break_continue.tish",
     "length.tish",
     "objects.tish",
+    "symbol.tish",
     "conditional.tish",
     "switch.tish",
     "do_while.tish",
@@ -714,6 +783,7 @@ fn test_mvp_programs_interp_vm_stdout_parity() {
 /// Compile each .tish file to native, run, and compare stdout to static expected (parallelized).
 #[test]
 fn test_mvp_programs_native() {
+    let _fast_native = EnvVarGuard::set("TISH_FAST_NATIVE_BUILD", "1");
     let core_dir = core_dir();
     let bin = tish_bin();
     assert!(
@@ -721,18 +791,86 @@ fn test_mvp_programs_native() {
         "tish binary not found at {}. Run `cargo build -p tishlang` first.",
         bin.display()
     );
-    let errors: Vec<String> = MVP_TEST_FILES
-        .par_iter()
+
+    let mut paths: Vec<PathBuf> = MVP_TEST_FILES
+        .iter()
         .filter_map(|name| {
-            let path = core_dir.join(name);
-            if !path.exists() {
-                return None;
+            let p = core_dir.join(name);
+            if p.exists() {
+                Some(p)
+            } else {
+                None
             }
-            let expected = match get_expected(&path) {
+        })
+        .collect();
+    paths.sort();
+
+    if paths.is_empty() {
+        return;
+    }
+
+    let combined = combined_mvp_native_inputs_hash(&paths);
+    let cache_dir = mvp_native_batch_cache_dir(combined);
+    let _ = std::fs::create_dir_all(&cache_dir);
+
+    let ext = if cfg!(target_os = "windows") {
+        ".exe"
+    } else {
+        ""
+    };
+
+    let entries_owned: Vec<(PathBuf, PathBuf)> = paths
+        .iter()
+        .map(|p| {
+            let stem = p.file_stem().unwrap().to_string_lossy();
+            let cached = cache_dir.join(format!("{}{}", stem, ext));
+            (p.clone(), cached)
+        })
+        .collect();
+
+    let need_build = entries_owned.iter().any(|(_, o)| !o.exists());
+    if need_build {
+        let refs: Vec<(&Path, &Path)> = entries_owned
+            .iter()
+            .map(|(a, b)| (a.as_path(), b.as_path()))
+            .collect();
+        let feats = native_build_features_for_integration_test();
+        compile_many_to_native(&refs, Some(workspace_root().as_path()), &feats, true)
+            .unwrap_or_else(|e| panic!("compile_many_to_native: {}", e.message));
+    }
+
+    // Run each binary sequentially. Parallel `fs::copy` + `exec` caused Linux ETXTBSY (errno 26)
+    // in CI when several threads replaced/ran temp executables under load.
+    let errors: Vec<String> = entries_owned
+        .iter()
+        .enumerate()
+        .filter_map(|(run_index, (path, cached_bin))| {
+            let expected = match get_expected(path) {
                 Some(e) => e,
                 None => return Some(format!("missing expected: {}", path.display())),
             };
-            let out_bin = compile_cached(&bin, &path, "native");
+            if !cached_bin.exists() {
+                return Some(format!("missing cached binary: {}", cached_bin.display()));
+            }
+            let stem = path.file_stem().unwrap().to_string_lossy();
+            let ext_bin = cached_bin
+                .extension()
+                .map(|e| e.to_string_lossy().to_string())
+                .unwrap_or_default();
+            let temp_dest = std::env::temp_dir().join(format!(
+                "tish_mvp_native_{}_{:x}_{}_{}",
+                stem,
+                file_content_hash(path),
+                std::process::id(),
+                run_index
+            ));
+            let temp_dest = if ext_bin.is_empty() {
+                temp_dest
+            } else {
+                temp_dest.with_extension(&ext_bin)
+            };
+            std::fs::copy(cached_bin, &temp_dest).expect("copy cached native bin to temp");
+            let out_bin = temp_dest;
             let out = match Command::new(&out_bin)
                 .current_dir(workspace_root())
                 .output()

package/crates/tish_ast/src/ast.rs

@@ -129,15 +129,9 @@ pub enum ImportSpecifier {
         alias_span: Option<Span>,
     },
     /// Namespace: * as M
-    Namespace {
-        name: Arc<str>,
-        name_span: Span,
-    },
+    Namespace { name: Arc<str>, name_span: Span },
     /// Default: import X from "..."
-    Default {
-        name: Arc<str>,
-        name_span: Span,
-    },
+    Default { name: Arc<str>, name_span: Span },
 }
 
 /// Export declaration: named (const/let/fn) or default
@@ -616,7 +610,7 @@ impl Statement {
             | Statement::DoWhile { span, .. }
             | Statement::Throw { span, .. }
             | Statement::Try { span, .. }
-            |             Statement::Import { span, .. }
+            | Statement::Import { span, .. }
             | Statement::Export { span, .. }
             | Statement::TypeAlias { span, .. }
             | Statement::DeclareVar { span, .. }

package/crates/tish_build_utils/src/lib.rs

@@ -6,6 +6,18 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::sync::Mutex;
+
+/// Serialize nested `cargo build` calls that share the workspace `target/` dir (tests + `tish build`).
+static NESTED_CARGO_MUTEX: Mutex<()> = Mutex::new(());
+
+fn mold_available() -> bool {
+    Command::new("mold")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
 
 /// True if `root` looks like the Tish language repo (has `crates/tish_runtime`).
 ///
@@ -161,7 +173,11 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
             let candidate = dir.join("tish");
             if is_tish_workspace_root(&candidate) {
                 return candidate.canonicalize().map_err(|e| {
-                    format!("Cannot canonicalize Tish workspace {}: {}", candidate.display(), e)
+                    format!(
+                        "Cannot canonicalize Tish workspace {}: {}",
+                        candidate.display(),
+                        e
+                    )
                 });
             }
             if !dir.pop() {
@@ -366,20 +382,31 @@ fn protoc_for_nested_cargo() -> Option<PathBuf> {
 /// Run cargo build in the given directory.
 /// If target_dir is Some, use that for --target-dir (e.g. workspace target for caching).
 pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<(), String> {
+    let _nested_guard = NESTED_CARGO_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
     let target_dir = target_dir
         .map(|p| p.to_path_buf())
         .unwrap_or_else(|| build_dir.join("target"));
+    let fast_native = std::env::var("TISH_FAST_NATIVE_BUILD").as_deref() == Ok("1");
+
     // Default to target-cpu=native so the emitted binary uses every SIMD / ISA
     // extension the build host supports. Callers can override by pre-setting
-    // RUSTFLAGS in the environment.
-    let existing_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
-    let merged_rustflags = if existing_rustflags.is_empty() {
-        "-C target-cpu=native".to_string()
-    } else if existing_rustflags.contains("target-cpu") {
-        existing_rustflags
-    } else {
-        format!("{} -C target-cpu=native", existing_rustflags)
-    };
+    // RUSTFLAGS in the environment. Skipped for fast nested builds (integration tests).
+    let mut merged_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
+    if fast_native {
+        if cfg!(target_os = "linux")
+            && mold_available()
+            && !merged_rustflags.contains("fuse-ld=mold")
+        {
+            merged_rustflags = format!("{} -C link-arg=-fuse-ld=mold", merged_rustflags.trim());
+            merged_rustflags = merged_rustflags.trim().to_string();
+        }
+    } else if merged_rustflags.is_empty() {
+        merged_rustflags = "-C target-cpu=native".to_string();
+    } else if !merged_rustflags.contains("target-cpu") {
+        merged_rustflags = format!("{} -C target-cpu=native", merged_rustflags);
+    }
+
     // Nested `cargo build` (e.g. `tish build --native-backend rust`) inherits the parent
     // environment. CI often sets `RUSTC_WRAPPER=sccache`; wrapping this inner compile too can
     // cause flaky or failed builds (LTO / temp-crate paths). Use plain rustc here; the main
@@ -394,6 +421,11 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
         .env_remove("CARGO_BUILD_RUSTC_WRAPPER")
         .env("CARGO_TERM_PROGRESS", "always")
         .env("RUSTFLAGS", &merged_rustflags);
+    if fast_native {
+        cmd.env("CARGO_INCREMENTAL", "1");
+    } else {
+        cmd.env_remove("CARGO_INCREMENTAL");
+    }
     if let Some(protoc) = protoc_for_nested_cargo() {
         cmd.env("PROTOC", protoc);
     }
@@ -422,11 +454,7 @@ mod protoc_tests {
         let _guard = _lock.lock().unwrap();
         std::env::remove_var("PROTOC");
         let p = protoc_for_nested_cargo().expect("expected vendored or PATH protoc");
-        assert!(
-            p.exists(),
-            "resolved protoc should exist: {}",
-            p.display()
-        );
+        assert!(p.exists(), "resolved protoc should exist: {}", p.display());
     }
 }
 

package/crates/tish_builtins/src/array.rs

@@ -1,10 +1,8 @@
 //! Array builtin methods.
 
 use crate::helpers::normalize_index;
-use tishlang_core::VmRef;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tishlang_core::Value;
+use tishlang_core::VmRef;
 
 /// Create a new array Value from a Vec of Values.
 pub fn from_vec(v: Vec<Value>) -> Value {
@@ -434,6 +432,7 @@ fn get_prop_number(v: &Value, prop: &std::sync::Arc<str>) -> f64 {
     match v {
         Value::Object(o) => o
             .borrow()
+            .strings
             .get(prop.as_ref())
             .map(|v| v.as_number().unwrap_or(f64::NAN))
             .unwrap_or(f64::NAN),

package/crates/tish_builtins/src/construct.rs

@@ -1,12 +1,8 @@
 //! `new` lowering for non-JS targets: `construct(callee, args)` approximates JS `[[Construct]]`.
 //! Browser-exact behavior remains on `tish build --target js`.
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
-use std::rc::Rc;
 use std::sync::Arc;
-
-use tishlang_core::{ObjectMap, Value};
+use tishlang_core::{ObjectMap, Value, VmRef};
 
 const CONSTRUCT: &str = "__construct";
 
@@ -16,7 +12,7 @@ pub fn construct(callee: &Value, args: &[Value]) -> Value {
         Value::Function(f) => f(args),
         Value::Object(o) => {
             let b = o.borrow();
-            if let Some(Value::Function(ctor)) = b.get(&Arc::from(CONSTRUCT)) {
+            if let Some(Value::Function(ctor)) = b.strings.get(&Arc::from(CONSTRUCT)) {
                 let c = ctor.clone();
                 drop(b);
                 return c(args);
@@ -30,7 +26,7 @@ pub fn construct(callee: &Value, args: &[Value]) -> Value {
 fn param(initial: f64) -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("value"), Value::Number(initial));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn connect_fn() -> Value {
@@ -45,21 +41,21 @@ fn audio_node_stub() -> Value {
     m.insert(Arc::from("frequency"), param(440.0));
     m.insert(Arc::from("Q"), param(1.0));
     m.insert(Arc::from("type"), Value::String("peaking".into()));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn analyser_stub() -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(Arc::from("fftSize"), Value::Number(2048.0));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn stereo_panner_stub() -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(Arc::from("pan"), param(0.0));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn audio_buffer_stub(len: usize) -> Value {
@@ -71,7 +67,7 @@ fn audio_buffer_stub(len: usize) -> Value {
         Arc::from("getChannelData"),
         Value::native(move |_args| Value::Array(data2.clone())),
     );
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn buffer_source_stub() -> Value {
@@ -79,12 +75,9 @@ fn buffer_source_stub() -> Value {
     m.insert(Arc::from("buffer"), Value::Null);
     m.insert(Arc::from("loop"), Value::Bool(false));
     m.insert(Arc::from("connect"), connect_fn());
-    m.insert(
-        Arc::from("start"),
-        Value::native(|_| Value::Null),
-    );
+    m.insert(Arc::from("start"), Value::native(|_| Value::Null));
     m.insert(Arc::from("stop"), Value::native(|_| Value::Null));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn oscillator_stub() -> Value {
@@ -92,12 +85,9 @@ fn oscillator_stub() -> Value {
     m.insert(Arc::from("frequency"), param(440.0));
     m.insert(Arc::from("type"), Value::String("sine".into()));
     m.insert(Arc::from("connect"), connect_fn());
-    m.insert(
-        Arc::from("start"),
-        Value::native(|_| Value::Null),
-    );
+    m.insert(Arc::from("start"), Value::native(|_| Value::Null));
     m.insert(Arc::from("stop"), Value::native(|_| Value::Null));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn audio_context_instance() -> Value {
@@ -140,12 +130,9 @@ fn audio_context_instance() -> Value {
         Arc::from("createOscillator"),
         Value::native(|_| oscillator_stub()),
     );
-    ctx.insert(
-        Arc::from("decodeAudioData"),
-        Value::native(|_| Value::Null),
-    );
+    ctx.insert(Arc::from("decodeAudioData"), Value::native(|_| Value::Null));
 
-    Value::Object(VmRef::new(ctx))
+    Value::object(ctx)
 }
 
 /// Global `Uint8Array` for native/VM: `new Uint8Array(n)` → numeric array of zeros (not real bytes).
@@ -160,7 +147,7 @@ pub fn uint8_array_constructor_value() -> Value {
     });
     let mut m = ObjectMap::default();
     m.insert(Arc::from(CONSTRUCT), ctor);
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 /// Global `AudioContext` for native/VM: stub graph (no real audio).
@@ -168,5 +155,5 @@ pub fn audio_context_constructor_value() -> Value {
     let ctor = Value::native(|_args: &[Value]| audio_context_instance());
     let mut m = ObjectMap::default();
     m.insert(Arc::from(CONSTRUCT), ctor);
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }