@tishlang/tish-format 2.39.0 → 3.0.0

package/crates/tish_core/src/json.rs

@@ -1,12 +1,21 @@
 //! JSON parsing and stringification for Tish values.
 
-use crate::{Value, VmRef};
-use std::sync::Arc;
+use crate::compat::{AHashMap, Arc};
+use crate::{NumArrayBacking, Value, VmRef};
+#[cfg(feature = "portable")]
+use crate::compat::FloatExt;
+#[cfg(feature = "portable")]
+use alloc::{
+    boxed::Box,
+    format,
+    string::{String, ToString},
+    vec::Vec,
+};
 
 /// 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>>;
+type KeyCache = AHashMap<Box<str>, Arc<str>>;
 
 #[inline]
 fn intern_key(cache: &mut KeyCache, s: &str) -> Arc<str> {
@@ -133,11 +142,11 @@ fn signal_circular_json_throw() {
     if !crate::has_pending_throw() {
         crate::set_pending_throw(Value::object_from_pairs([
             (
-                std::sync::Arc::from("name"),
+                Arc::from("name"),
                 Value::String("TypeError".into()),
             ),
             (
-                std::sync::Arc::from("message"),
+                Arc::from("message"),
                 Value::String("Converting circular structure to JSON".into()),
             ),
         ]));
@@ -178,11 +187,24 @@ fn json_stringify_into_guarded(buf: &mut String, value: &Value, ancestors: &mut
         Value::NumberArray(arr) => {
             let borrowed = arr.borrow();
             buf.push('[');
-            for (i, n) in borrowed.iter().enumerate() {
-                if i > 0 {
-                    buf.push(',');
+            match &*borrowed {
+                NumArrayBacking::Packed(nums) => {
+                    for (i, n) in nums.iter().enumerate() {
+                        if i > 0 {
+                            buf.push(',');
+                        }
+                        write_json_number(buf, *n);
+                    }
+                }
+                // A deopted numeric array serializes element-by-element like a boxed Array.
+                NumArrayBacking::Boxed(items) => {
+                    for (i, item) in items.iter().enumerate() {
+                        if i > 0 {
+                            buf.push(',');
+                        }
+                        json_stringify_into_guarded(buf, item, ancestors);
+                    }
                 }
-                write_json_number(buf, *n);
             }
             buf.push(']');
         }
@@ -217,6 +239,14 @@ fn json_stringify_into_guarded(buf: &mut String, value: &Value, ancestors: &mut
         }
         #[cfg(feature = "regex")]
         Value::RegExp(_) => buf.push_str("null"),
+        // A boxed typed struct serialises like the object it is: materialise once and recurse. (This is
+        // the generic path; codegen also has a direct `__tish_json_TishStruct_*` fast path that never
+        // boxes to a struct-Value in the first place, used when the static type is known.)
+        #[cfg(feature = "portable")]
+        Value::Struct(s) => {
+            let obj = s.borrow().tish_to_object();
+            json_stringify_into_guarded(buf, &obj, ancestors);
+        }
     }
 }
 
@@ -253,7 +283,7 @@ pub fn escape_json_string_into(buf: &mut String, s: &str) {
                 b'\x08' => buf.push_str("\\b"),
                 b'\x0c' => buf.push_str("\\f"),
                 _ => {
-                    use std::fmt::Write;
+                    use core::fmt::Write;
                     let _ = write!(buf, "\\u{:04x}", b as u32);
                 }
             }
@@ -509,6 +539,7 @@ fn parse_object<'a>(
             Value::Object(VmRef::new(crate::ObjectData {
                 strings: map,
                 symbols: None,
+                frozen: false,
             })),
             rest,
         ));
@@ -539,6 +570,7 @@ fn parse_object<'a>(
                     Value::Object(VmRef::new(crate::ObjectData {
                         strings: map,
                         symbols: None,
+                        frozen: false,
                     })),
                     &input[1..],
                 ));

package/crates/tish_core/src/lib.rs

@@ -2,7 +2,34 @@
 //!
 //! This crate provides the unified Value type and utilities used by both
 //! the interpreter (tishlang_eval) and compiled runtime (tishlang_runtime).
+#![cfg_attr(feature = "portable", no_std)]
 
+// `portable` (no_std, Arc→Rc) and `send-values` (parking_lot, std-only) are mutually
+// exclusive; unified by Cargo's additive features they'd try to compile parking_lot for a
+// no_std target with a confusing far-from-root-cause error. Fail loudly at the source instead.
+#[cfg(all(feature = "portable", feature = "send-values"))]
+compile_error!("tishlang_core features `portable` and `send-values` are mutually exclusive");
+
+// `portable` implies `#![no_std]`, so `std` must be OFF (depend on this crate as
+// `default-features = false, features = ["portable"]`). If both are on — the usual slip of
+// requesting `portable` without disabling the default `std` feature — the `no_std` attribute
+// above still applies while the `std`-only deps (ahash/arcstr) are pulled in, producing a
+// confusing cascade. Catch it at the source with a message that names the fix.
+#[cfg(all(feature = "portable", feature = "std"))]
+compile_error!(
+    "tishlang_core feature `portable` requires `default-features = false` (the default `std` feature must be disabled)"
+);
+
+extern crate alloc;
+
+#[cfg(feature = "portable")]
+use alloc::{
+    format,
+    string::{String, ToString},
+    vec::Vec,
+};
+
+mod compat;
 mod console_style;
 mod json;
 mod macros;
@@ -11,13 +38,38 @@ mod uri;
 mod value;
 mod vmref;
 
+/// Hidden re-export so the exported `tish_module!` macro can name the right
+/// smart pointer (`std::sync::Arc` on host, `Rc` under `portable`) at its
+/// expansion sites without leaking the private `compat` module.
+#[doc(hidden)]
+pub use compat::Arc as __TishArc;
+
+/// Portable-runtime surface consumed by `tishlang_builtins` and the GBA facade
+/// (`tishlang_runtime_gba`): the libm-backed float trait and the installable
+/// clock / RNG hooks. Only present under `portable`.
+#[cfg(feature = "portable")]
+pub use compat::{
+    install_clock, install_rng, next_u64, now_ms, random_f64, seed_rng, FloatExt, SingleCore,
+};
+
 pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
 pub use json::{
     escape_json_string_into, json_parse, json_stringify, json_stringify_into, write_json_number,
 };
 pub use shape::{ShapeId, DICT_SHAPE, EMPTY_SHAPE};
 pub use uri::{percent_decode, percent_decode_component, percent_encode, percent_encode_component};
-pub use arcstr::ArcStr;
+pub use compat::ArcStr;
+/// The core type vocabulary, re-exported so `tishlang_builtins`, generated code,
+/// and the GBA facade share one source of truth: `Arc` (std `Arc` / `Rc` under
+/// `portable`), and the object hasher (`ahash` / `FxHasher`). Names match the std
+/// originals so hosted call sites are unchanged.
+pub use compat::{AHashMap, Arc, RandomState};
+/// Lock / once-cell vocabulary, namespaced to avoid polluting the crate root:
+/// std `sync` types on the host, single-core shims under `portable`. Used by
+/// `tishlang_builtins` for its symbol registry.
+pub mod sync {
+    pub use crate::compat::{Mutex, OnceLock, RwLock};
+}
 pub use value::*;
 pub use vmref::{VmReadGuard, VmRef, VmWriteGuard};
 
@@ -26,20 +78,34 @@ pub use vmref::{VmReadGuard, VmRef, VmWriteGuard};
 /// `[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
+#[cfg(not(feature = "portable"))]
 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.
+/// No-op under `portable` (an embedded GBA ROM has no process argv).
+#[cfg(not(feature = "portable"))]
 pub fn set_process_argv(argv: Vec<String>) {
     let _ = PROCESS_ARGV.set(argv);
 }
 
+/// See [`set_process_argv`]. No-op under `portable`.
+#[cfg(feature = "portable")]
+pub fn set_process_argv(_argv: Vec<String>) {}
+
 /// The argv a script should see as `process.argv`: the [`set_process_argv`] override if present,
-/// else the host process's `std::env::args()`.
+/// else the host process's `std::env::args()`. Empty under `portable`.
 pub fn process_argv() -> Vec<String> {
-    match PROCESS_ARGV.get() {
-        Some(v) => v.clone(),
-        None => std::env::args().collect(),
+    #[cfg(not(feature = "portable"))]
+    {
+        match PROCESS_ARGV.get() {
+            Some(v) => v.clone(),
+            None => std::env::args().collect(),
+        }
+    }
+    #[cfg(feature = "portable")]
+    {
+        Vec::new()
     }
 }
 
@@ -54,9 +120,14 @@ pub fn process_argv() -> Vec<String> {
 /// can poll it without a `builtins -> runtime` dependency cycle; `tishlang_runtime` and `tishlang_vm`
 /// share this one slot. First-throw-wins; drained exactly once by [`take_pending_throw`] at the frame
 /// that converts it back into a `Result`.
+#[cfg(not(feature = "portable"))]
 thread_local! {
-    static PENDING_THROW: std::cell::RefCell<Option<Value>> = const { std::cell::RefCell::new(None) };
+    static PENDING_THROW: core::cell::RefCell<Option<Value>> = const { core::cell::RefCell::new(None) };
 }
+// Single-core: a plain static with the same `.with()` API. See compat::SingleCore.
+#[cfg(feature = "portable")]
+static PENDING_THROW: compat::SingleCore<core::cell::RefCell<Option<Value>>> =
+    compat::SingleCore::new(core::cell::RefCell::new(None));
 
 /// Park a thrown value to propagate across a non-`Result` boundary. First-throw-wins: if one is
 /// already pending (an erroneous continuation reached a second throw before the slot was drained),
@@ -80,13 +151,17 @@ pub fn take_pending_throw() -> Option<Value> {
     PENDING_THROW.with(|c| c.borrow_mut().take())
 }
 
+// Current user-function call depth for the bytecode VM. The VM's recursive path builds a fresh
+// `Vm` per call (so no shared struct field can accumulate) and its `Callable::call` signature is
+// fixed — a thread-local is the VM's equivalent of the interpreter's shared `Rc<Cell>` counter.
+// Lives here (not `tish_vm`) beside `PENDING_THROW` for the same layering reason. #381
+#[cfg(not(feature = "portable"))]
 thread_local! {
-    /// Current user-function call depth for the bytecode VM. The VM's recursive path builds a fresh
-    /// `Vm` per call (so no shared struct field can accumulate) and its `Callable::call` signature is
-    /// fixed — a thread-local is the VM's equivalent of the interpreter's shared `Rc<Cell>` counter.
-    /// Lives here (not `tish_vm`) beside `PENDING_THROW` for the same layering reason. #381
-    static CALL_DEPTH: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    static CALL_DEPTH: core::cell::Cell<usize> = const { core::cell::Cell::new(0) };
 }
+#[cfg(feature = "portable")]
+static CALL_DEPTH: compat::SingleCore<core::cell::Cell<usize>> =
+    compat::SingleCore::new(core::cell::Cell::new(0));
 
 /// Enter one VM call frame; returns the new depth. Pair every call with [`dec_call_depth`].
 #[inline]
@@ -107,14 +182,32 @@ pub fn dec_call_depth() {
 /// Default recursion ceiling shared by every backend that counts call depth (#381). Chosen with the
 /// interpreter: comfortably deep for real programs, but reached long before counted recursion can
 /// exhaust memory or the stack.
+#[cfg(not(target_arch = "wasm32"))]
 pub const DEFAULT_MAX_CALL_DEPTH: usize = 20_000;
 
+/// wasm32 ceiling (#531). On wasm the embedded VM runs on the single guest stack — there is no host
+/// worker thread to grow into (`Vm` can't spawn on wasm), and the host runtime (wasmtime) bounds
+/// guest call depth by its own `max_wasm_stack`. That limit is NOT reachable from the `.wasm`: it
+/// overflows into an UNCATCHABLE module trap after only ~300 `Vm::run_chunk` frames — the tish
+/// function locals live in the VM operand stack, so the per-frame host cost is ~constant regardless
+/// of the program, and the trap depth is a stable ~310 under default wasmtime. A far lower ceiling
+/// keeps the frame-counting guard firing first (measured safe with margin below the trap), so deep
+/// recursion raises a CATCHABLE `RangeError` on WASI too — matching interp/vm/native rather than
+/// aborting the process. WASI programs are thus capped much shallower than native; that is inherent
+/// to wasm's host-bounded call stack, not a tish choice.
+#[cfg(target_arch = "wasm32")]
+pub const DEFAULT_MAX_CALL_DEPTH: usize = 256;
+
+// The recursion ceiling, lazily initialized from `TISH_MAX_CALL_DEPTH` (0 = uninitialized). A
+// thread-local Cell (not OnceLock) so tests can override it per-thread without racing the
+// process-wide env. Shared by the VM's guard and the native backend's boxed-call guard. #381
+#[cfg(not(feature = "portable"))]
 thread_local! {
-    // The recursion ceiling, lazily initialized from `TISH_MAX_CALL_DEPTH` (0 = uninitialized). A
-    // thread-local Cell (not OnceLock) so tests can override it per-thread without racing the
-    // process-wide env. Shared by the VM's guard and the native backend's boxed-call guard. #381
-    static MAX_CALL_DEPTH: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    static MAX_CALL_DEPTH: core::cell::Cell<usize> = const { core::cell::Cell::new(0) };
 }
+#[cfg(feature = "portable")]
+static MAX_CALL_DEPTH: compat::SingleCore<core::cell::Cell<usize>> =
+    compat::SingleCore::new(core::cell::Cell::new(0));
 
 /// The recursion ceiling for depth-counting guards: user-fn calls deeper than this raise a catchable
 /// `RangeError` instead of overflowing the native stack. `TISH_MAX_CALL_DEPTH` overrides (default
@@ -125,11 +218,14 @@ pub fn max_call_depth() -> usize {
         if v != 0 {
             return v;
         }
+        #[cfg(not(feature = "portable"))]
         let init = std::env::var("TISH_MAX_CALL_DEPTH")
             .ok()
             .and_then(|s| s.parse::<usize>().ok())
             .filter(|&n| n > 0)
             .unwrap_or(DEFAULT_MAX_CALL_DEPTH);
+        #[cfg(feature = "portable")]
+        let init = DEFAULT_MAX_CALL_DEPTH;
         c.set(init);
         init
     })
@@ -146,11 +242,11 @@ pub fn set_max_call_depth_for_test(n: usize) {
 pub fn stack_overflow_error() -> Value {
     let mut e = ObjectMap::default();
     e.insert(
-        std::sync::Arc::from("name"),
+        Arc::from("name"),
         Value::String("RangeError".into()),
     );
     e.insert(
-        std::sync::Arc::from("message"),
+        Arc::from("message"),
         Value::String("Maximum call stack size exceeded".into()),
     );
     Value::object(e)
@@ -163,11 +259,11 @@ pub fn stack_overflow_error() -> Value {
 pub fn not_a_function_error(message: impl Into<String>) -> Value {
     let mut e = ObjectMap::default();
     e.insert(
-        std::sync::Arc::from("name"),
+        Arc::from("name"),
         Value::String("TypeError".into()),
     );
     e.insert(
-        std::sync::Arc::from("message"),
+        Arc::from("message"),
         Value::String(message.into().into()),
     );
     Value::object(e)
@@ -179,11 +275,11 @@ pub fn not_a_function_error(message: impl Into<String>) -> Value {
 pub fn type_error(message: impl Into<String>) -> Value {
     let mut e = ObjectMap::default();
     e.insert(
-        std::sync::Arc::from("name"),
+        Arc::from("name"),
         Value::String("TypeError".into()),
     );
     e.insert(
-        std::sync::Arc::from("message"),
+        Arc::from("message"),
         Value::String(message.into().into()),
     );
     Value::object(e)
@@ -207,11 +303,11 @@ pub fn str_to_array_index(s: &str) -> Option<usize> {
 pub fn range_error(message: impl Into<String>) -> Value {
     let mut e = ObjectMap::default();
     e.insert(
-        std::sync::Arc::from("name"),
+        Arc::from("name"),
         Value::String("RangeError".into()),
     );
     e.insert(
-        std::sync::Arc::from("message"),
+        Arc::from("message"),
         Value::String(message.into().into()),
     );
     Value::object(e)
@@ -224,11 +320,11 @@ pub fn range_error(message: impl Into<String>) -> Value {
 pub fn cannot_read_property_error(prop: &str) -> Value {
     let mut e = ObjectMap::default();
     e.insert(
-        std::sync::Arc::from("name"),
+        Arc::from("name"),
         Value::String("TypeError".into()),
     );
     e.insert(
-        std::sync::Arc::from("message"),
+        Arc::from("message"),
         Value::String(format!("Cannot read property '{}' of null", prop).into()),
     );
     Value::object(e)

package/crates/tish_core/src/macros.rs

@@ -23,7 +23,7 @@
 #[macro_export]
 macro_rules! tish_module {
     ($($name:expr => $fn:expr),* $(,)?) => {{
-        use std::sync::Arc;
+        use $crate::__TishArc as Arc;
         use $crate::{ObjectMap, Value};
         let mut map = ObjectMap::default();
         $(

package/crates/tish_core/src/shape.rs

@@ -12,7 +12,9 @@
 //! `PropMap` on a cache miss). Phase 1b will attach the ordered key list to each shape so objects can
 //! drop per-object key storage entirely (the butterfly representation).
 
-use std::sync::{Arc, OnceLock, RwLock};
+use crate::compat::{AHashMap, Arc, OnceLock, RwLock};
+#[cfg(feature = "portable")]
+use alloc::{vec, vec::Vec};
 
 /// Identity of an object's ordered key-set.
 pub type ShapeId = u32;
@@ -31,7 +33,7 @@ pub const DICT_SHAPE: ShapeId = u32::MAX;
 /// ahash is ~2–3× faster on short string keys. Random-seeded per process, so no HashDoS regression.
 #[derive(Default)]
 struct ShapeNode {
-    transitions: ahash::AHashMap<Arc<str>, ShapeId>,
+    transitions: AHashMap<Arc<str>, ShapeId>,
 }
 
 struct Registry {

package/crates/tish_core/src/uri.rs

@@ -1,5 +1,12 @@
 //! URI encoding/decoding utilities.
 
+#[cfg(feature = "portable")]
+use alloc::{
+    format,
+    string::{String, ToString},
+    vec::Vec,
+};
+
 /// Percent-decode a string (for decodeURI).
 /// Does NOT decode reserved URI characters: ; / ? : @ & = + $ , #
 /// These are characters that encodeURI does not encode, so decodeURI won't decode them.
@@ -98,7 +105,7 @@ pub fn percent_decode_component(input: &str) -> Result<String, String> {
     while i < bytes.len() {
         if bytes[i] == b'%' {
             if i + 2 < bytes.len() {
-                if let Some(b) = std::str::from_utf8(&bytes[i + 1..i + 3])
+                if let Some(b) = core::str::from_utf8(&bytes[i + 1..i + 3])
                     .ok()
                     .and_then(|s| u8::from_str_radix(s, 16).ok())
                 {