@tishlang/tish-format 2.39.0 → 3.0.0

package/crates/tish_builtins/src/array.rs

@@ -1,5 +1,9 @@
 //! Array builtin methods.
 
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
 use crate::helpers::normalize_index;
 use tishlang_core::Value;
 use tishlang_core::VmRef;
@@ -18,7 +22,7 @@ pub fn from_vec(v: Vec<Value>) -> Value {
 pub fn snapshot_values(arr: &Value) -> Vec<Value> {
     match arr {
         Value::Array(a) => a.borrow().clone(),
-        Value::NumberArray(a) => a.borrow().iter().map(|&n| Value::Number(n)).collect(),
+        Value::NumberArray(a) => a.borrow().to_values(),
         _ => Vec::new(),
     }
 }
@@ -30,19 +34,24 @@ pub fn snapshot_values(arr: &Value) -> Vec<Value> {
 /// unboxed f64 fast path for it too. The `None` result drives the fused lowering back to its boxed
 /// loop, so any non-numeric element is handled with identical `Value` semantics.
 pub fn as_f64_snapshot(arr: &Value) -> Option<Vec<f64>> {
-    match arr {
-        Value::NumberArray(a) => Some(a.borrow().clone()),
-        Value::Array(a) => {
-            let b = a.borrow();
-            let mut out: Vec<f64> = Vec::with_capacity(b.len());
-            for v in b.iter() {
-                match v {
-                    Value::Number(n) => out.push(*n),
-                    _ => return None,
-                }
+    let extract = |vals: &[Value]| -> Option<Vec<f64>> {
+        let mut out: Vec<f64> = Vec::with_capacity(vals.len());
+        for v in vals {
+            match v {
+                Value::Number(n) => out.push(*n),
+                _ => return None,
             }
-            Some(out)
         }
+        Some(out)
+    };
+    match arr {
+        // Still packed: clone the f64s directly. Deopted: extract from the boxed values (None if
+        // any is non-numeric — the caller then uses the boxed path).
+        Value::NumberArray(a) => match a.borrow().as_packed() {
+            Some(v) => Some(v.clone()),
+            None => extract(a.borrow().as_boxed().map(|v| v.as_slice()).unwrap_or(&[])),
+        },
+        Value::Array(a) => extract(&a.borrow()),
         _ => None,
     }
 }
@@ -60,10 +69,10 @@ pub fn len(arr: &Value) -> Option<usize> {
 /// can use this deopt helper rather than changing every `if let Value::Array` branch.
 /// Returns the original value unchanged for anything that isn't a `NumberArray`.
 #[inline]
-fn as_boxed_array(arr: &Value) -> std::borrow::Cow<'_, Value> {
+fn as_boxed_array(arr: &Value) -> alloc::borrow::Cow<'_, Value> {
     match arr {
-        Value::NumberArray(na) => std::borrow::Cow::Owned(Value::materialize_number_array(na)),
-        other => std::borrow::Cow::Borrowed(other),
+        Value::NumberArray(na) => alloc::borrow::Cow::Owned(Value::materialize_number_array(na)),
+        other => alloc::borrow::Cow::Borrowed(other),
     }
 }
 
@@ -81,7 +90,9 @@ fn packed_snapshot<'c>(
     callback: &'c Value,
 ) -> Option<(Vec<f64>, &'c tishlang_core::NativeFn)> {
     match (arr, callback) {
-        (Value::NumberArray(na), Value::Function(cb)) => Some((na.borrow().clone(), cb)),
+        (Value::NumberArray(na), Value::Function(cb)) => {
+            na.borrow().as_packed().map(|v| (v.clone(), cb))
+        }
         _ => None,
     }
 }
@@ -282,8 +293,20 @@ pub fn shuffle(arr: &Value) -> Value {
     let arr = as_boxed_array(arr); let arr = &*arr;
     if let Value::Array(arr) = arr {
         let mut v = arr.borrow().clone();
-        use rand::seq::SliceRandom;
-        v.shuffle(&mut rand::rng());
+        #[cfg(not(feature = "portable"))]
+        {
+            use rand::seq::SliceRandom;
+            v.shuffle(&mut rand::rng());
+        }
+        // Fisher-Yates with the runtime RNG hook (no `rand` on GBA).
+        #[cfg(feature = "portable")]
+        {
+            let n = v.len();
+            for i in (1..n).rev() {
+                let j = (tishlang_core::next_u64() % (i as u64 + 1)) as usize;
+                v.swap(i, j);
+            }
+        }
         Value::Array(VmRef::new(v))
     } else {
         Value::Null
@@ -404,10 +427,13 @@ pub fn concat(arr: &Value, args: &[Value]) -> Value {
     if let Value::Array(arr) = arr {
         let mut result = arr.borrow().clone();
         for v in args {
-            if let Value::Array(other) = v {
-                result.extend(other.borrow().iter().cloned());
-            } else {
-                result.push(v.clone());
+            match v {
+                Value::Array(other) => result.extend(other.borrow().iter().cloned()),
+                // A packed `NumberArray` arg spreads its numbers, same as a boxed array — under
+                // TISH_PACKED_ARRAYS=1 a numeric literal `[3,4]` is a NumberArray, so
+                // `[1,2].concat([3,4])` must flatten to `[1,2,3,4]`, not push the array whole.
+                Value::NumberArray(other) => result.extend(other.borrow().to_values()),
+                _ => result.push(v.clone()),
             }
         }
         Value::Array(VmRef::new(result))
@@ -421,9 +447,19 @@ pub fn flat(arr: &Value, depth: &Value) -> Value {
     fn flatten(arr: &[Value], depth: i32, result: &mut Vec<Value>) {
         for v in arr {
             if depth > 0 {
-                if let Value::Array(inner) = v {
-                    flatten(&inner.borrow(), depth - 1, result);
-                    continue;
+                match v {
+                    Value::Array(inner) => {
+                        flatten(&inner.borrow(), depth - 1, result);
+                        continue;
+                    }
+                    // A packed `NumberArray` inner flattens like a boxed array (its numbers are the
+                    // flattened elements) — `[[1,2],[3,4]].flat()` where the inners packed must not
+                    // leave a `NumberArray` sitting as a scalar element.
+                    Value::NumberArray(inner) => {
+                        result.extend(inner.borrow().to_values());
+                        continue;
+                    }
+                    _ => {}
                 }
             }
             result.push(v.clone());
@@ -871,7 +907,7 @@ pub fn flat_map(arr: &Value, callback: &Value) -> Value {
 
 fn sort_by_impl<F>(arr: &Value, cmp: F) -> Value
 where
-    F: FnMut(&Value, &Value) -> std::cmp::Ordering,
+    F: FnMut(&Value, &Value) -> core::cmp::Ordering,
 {
     if let Value::Array(arr) = arr {
         arr.borrow_mut().sort_by(cmp);
@@ -895,7 +931,7 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
         // Mutex under send-values and self-deadlock the worker (or panic under RefCell) — the exact
         // reentrant-lock class fixed for the captured-cell path in #218/#338. `mem::take` leaves the
         // array empty for the duration of the sort; the final result is written back below.
-        let mut elements: Vec<Value> = std::mem::take(&mut *arr.borrow_mut());
+        let mut elements: Vec<Value> = core::mem::take(&mut *arr.borrow_mut());
         let len = elements.len();
         let mut indices: Vec<usize> = (0..len).collect();
         let mut args_buf: [Value; 2] = [Value::Null, Value::Null];
@@ -904,14 +940,14 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
             // #303: once the comparator has thrown, stop invoking it — return Equal so the sort can
             // unwind. Avoids extra comparator calls (and their side effects) after the throw.
             if tishlang_core::has_pending_throw() {
-                return std::cmp::Ordering::Equal;
+                return core::cmp::Ordering::Equal;
             }
             args_buf[0] = elements[a].clone();
             args_buf[1] = elements[b].clone();
             match cmp_fn.call(&args_buf) {
-                Value::Number(n) if n < 0.0 => std::cmp::Ordering::Less,
-                Value::Number(n) if n > 0.0 => std::cmp::Ordering::Greater,
-                _ => std::cmp::Ordering::Equal,
+                Value::Number(n) if n < 0.0 => core::cmp::Ordering::Less,
+                Value::Number(n) if n > 0.0 => core::cmp::Ordering::Greater,
+                _ => core::cmp::Ordering::Equal,
             }
         });
 
@@ -923,7 +959,7 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
         } else {
             let sorted: Vec<Value> = indices
                 .into_iter()
-                .map(|i| std::mem::replace(&mut elements[i], Value::Null))
+                .map(|i| core::mem::replace(&mut elements[i], Value::Null))
                 .collect();
             *arr.borrow_mut() = sorted;
         }
@@ -933,12 +969,12 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
     }
 }
 
-fn num_cmp(a: &Value, b: &Value, asc: bool) -> std::cmp::Ordering {
+fn num_cmp(a: &Value, b: &Value, asc: bool) -> core::cmp::Ordering {
     let (na, nb) = match (a, b) {
         (Value::Number(a), Value::Number(b)) => (*a, *b),
         _ => (f64::NAN, f64::NAN),
     };
-    let cmp = na.partial_cmp(&nb).unwrap_or(std::cmp::Ordering::Equal);
+    let cmp = na.partial_cmp(&nb).unwrap_or(core::cmp::Ordering::Equal);
     if asc {
         cmp
     } else {
@@ -961,13 +997,15 @@ pub fn sort_numeric_desc(arr: &Value) -> Value {
 fn sort_numeric_impl(arr: &Value, asc: bool) -> Value {
     // NumberArray fast path: sort the Vec<f64> directly — no unbox pass, no rebox.
     if let Value::NumberArray(a) = arr {
-        let mut g = a.borrow_mut();
-        if asc {
-            g.sort_unstable_by(|x, y| x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal));
-        } else {
-            g.sort_unstable_by(|x, y| y.partial_cmp(x).unwrap_or(std::cmp::Ordering::Equal));
+        // Fast path only while still packed; a deopted numeric array sorts via the boxed path below.
+        if let Some(nums) = a.borrow_mut().as_packed_mut() {
+            if asc {
+                nums.sort_unstable_by(|x, y| x.partial_cmp(y).unwrap_or(core::cmp::Ordering::Equal));
+            } else {
+                nums.sort_unstable_by(|x, y| y.partial_cmp(x).unwrap_or(core::cmp::Ordering::Equal));
+            }
+            return Value::NumberArray(a.clone());
         }
-        return Value::NumberArray(a.clone());
     }
     if let Value::Array(a) = arr {
         {
@@ -982,11 +1020,11 @@ fn sort_numeric_impl(arr: &Value, asc: bool) -> Value {
                     .collect();
                 if asc {
                     nums.sort_unstable_by(|x, y| {
-                        x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal)
+                        x.partial_cmp(y).unwrap_or(core::cmp::Ordering::Equal)
                     });
                 } else {
                     nums.sort_unstable_by(|x, y| {
-                        y.partial_cmp(x).unwrap_or(std::cmp::Ordering::Equal)
+                        y.partial_cmp(x).unwrap_or(core::cmp::Ordering::Equal)
                     });
                 }
                 for (slot, n) in g.iter_mut().zip(nums) {
@@ -1004,11 +1042,11 @@ fn sort_numeric_impl(arr: &Value, asc: bool) -> Value {
 
 /// Sort array of objects by numeric property: arr.sort((a,b)=>a.prop-b.prop)
 pub fn sort_by_property_numeric(arr: &Value, prop: &str, asc: bool) -> Value {
-    let prop_arc = std::sync::Arc::from(prop);
+    let prop_arc = tishlang_core::Arc::from(prop);
     sort_by_impl(arr, move |a, b| {
         let na = get_prop_number(a, &prop_arc);
         let nb = get_prop_number(b, &prop_arc);
-        let cmp = na.partial_cmp(&nb).unwrap_or(std::cmp::Ordering::Equal);
+        let cmp = na.partial_cmp(&nb).unwrap_or(core::cmp::Ordering::Equal);
         if asc {
             cmp
         } else {
@@ -1017,7 +1055,7 @@ pub fn sort_by_property_numeric(arr: &Value, prop: &str, asc: bool) -> Value {
     })
 }
 
-fn get_prop_number(v: &Value, prop: &std::sync::Arc<str>) -> f64 {
+fn get_prop_number(v: &Value, prop: &tishlang_core::Arc<str>) -> f64 {
     match v {
         Value::Object(o) => o
             .borrow()
@@ -1097,19 +1135,19 @@ pub fn sort_by_keys(arr: &Value, keys: &[(&[&str], bool)]) -> Value {
             for (col, (_, asc)) in keys.iter().enumerate() {
                 let ord = ka[col]
                     .partial_cmp(&kb[col])
-                    .unwrap_or(std::cmp::Ordering::Equal);
+                    .unwrap_or(core::cmp::Ordering::Equal);
                 let ord = if *asc { ord } else { ord.reverse() };
-                if ord != std::cmp::Ordering::Equal {
+                if ord != core::cmp::Ordering::Equal {
                     return ord;
                 }
             }
-            std::cmp::Ordering::Equal
+            core::cmp::Ordering::Equal
         });
         // Undecorate: apply the permutation in place.
-        let mut elements: Vec<Value> = std::mem::take(&mut *g);
+        let mut elements: Vec<Value> = core::mem::take(&mut *g);
         *g = decorated
             .into_iter()
-            .map(|(i, _)| std::mem::replace(&mut elements[i], Value::Null))
+            .map(|(i, _)| core::mem::replace(&mut elements[i], Value::Null))
             .collect();
         drop(g);
         Value::Array(a.clone())
@@ -1125,15 +1163,15 @@ mod packed_hof_tests {
     //! on it. These run with packing semantics directly (the helpers don't read the env flag; a
     //! `NumberArray` value is enough to take the fast path).
     use super::*;
-    use tishlang_core::Value;
+    use tishlang_core::{NumArrayBacking, Value};
 
     fn na(xs: &[f64]) -> Value {
-        Value::NumberArray(VmRef::new(xs.to_vec()))
+        Value::NumberArray(VmRef::new(NumArrayBacking::Packed(xs.to_vec())))
     }
     fn nums(v: &Value) -> Vec<f64> {
         match v {
             Value::Array(a) => a.borrow().iter().map(|e| e.as_number().unwrap_or(f64::NAN)).collect(),
-            Value::NumberArray(a) => a.borrow().clone(),
+            Value::NumberArray(a) => a.borrow().to_values().iter().map(|e| e.as_number().unwrap_or(f64::NAN)).collect(),
             _ => vec![],
         }
     }
@@ -1317,7 +1355,7 @@ mod sort_by_keys_tests {
     //! EXACT same order as running the equivalent boxed comparator through
     //! `sort_with_comparator`, since cross-backend parity depends on it.
     use super::*;
-    use std::sync::Arc;
+    use tishlang_core::Arc;
     use tishlang_core::Value;
 
     fn rec(key: f64, idx: f64) -> Value {
@@ -1533,4 +1571,42 @@ mod reentrancy_tests_382 {
             _ => panic!("sort should return an array"),
         }
     }
+
+    fn nums(v: &Value) -> Vec<f64> {
+        match v {
+            Value::Array(a) => a.borrow().iter().filter_map(|e| e.as_number()).collect(),
+            _ => panic!("expected boxed array result"),
+        }
+    }
+
+    /// #505: a packed `NumberArray` concat ARG must spread its numbers, not push the array whole.
+    #[test]
+    fn concat_spreads_packed_number_array_arg() {
+        let recv = Value::Array(VmRef::new(vec![Value::Number(1.0), Value::Number(2.0)]));
+        let packed = Value::number_array(vec![3.0, 4.0]);
+        let out = concat(&recv, &[packed]);
+        assert_eq!(nums(&out), vec![1.0, 2.0, 3.0, 4.0]);
+        // Mixed with a boxed array + a scalar, order preserved.
+        let boxed = Value::Array(VmRef::new(vec![Value::Number(5.0)]));
+        let out2 = concat(&recv, &[boxed, Value::Number(9.0)]);
+        assert_eq!(nums(&out2), vec![1.0, 2.0, 5.0, 9.0]);
+    }
+
+    /// #507: a packed `NumberArray` INNER element must flatten like a boxed array.
+    #[test]
+    fn flat_flattens_packed_number_array_inner() {
+        let outer = Value::Array(VmRef::new(vec![
+            Value::number_array(vec![1.0, 2.0]),
+            Value::Number(3.0),
+            Value::Array(VmRef::new(vec![Value::Number(4.0)])),
+        ]));
+        let out = flat(&outer, &Value::Number(1.0));
+        assert_eq!(nums(&out), vec![1.0, 2.0, 3.0, 4.0]);
+        // depth 0 keeps the packed inner as-is (not flattened) — matches boxed-array behavior.
+        let out0 = flat(&outer, &Value::Number(0.0));
+        match out0 {
+            Value::Array(a) => assert_eq!(a.borrow().len(), 3, "depth 0 flattens nothing"),
+            _ => panic!("expected array"),
+        }
+    }
 }

package/crates/tish_builtins/src/collections.rs

@@ -23,9 +23,13 @@
 //! - Keys/values use **SameValueZero** equality (NaN equals NaN; `+0`/`-0` are the same; objects by
 //!   identity).
 
-use std::any::Any;
-use std::hash::{Hash, Hasher};
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
+use core::any::Any;
+use core::hash::{Hash, Hasher};
+use tishlang_core::Arc;
 
 use indexmap::IndexMap;
 use tishlang_core::{NativeFn, ObjectMap, TishOpaque, Value, VmRef};
@@ -120,7 +124,7 @@ impl indexmap::Equivalent<Key> for KeyRef<'_> {
 /// stores `Value::Null` values and iterates its keys; a `Map` stores the mapped value. Uses `ahash`
 /// (the same fast hasher `tish_core`'s `PropMap` uses) rather than the default SipHash — iteration
 /// order is insertion order regardless of the hasher, so this is a pure constant-factor speedup.
-type Store = VmRef<IndexMap<Key, Value, ahash::RandomState>>;
+type Store = VmRef<IndexMap<Key, Value, tishlang_core::RandomState>>;
 
 /// Opaque whose length reports a collection's live element count. Stored under [`SIZE_SLOT`] on every
 /// `Set`/`Map` instance.
@@ -226,7 +230,7 @@ fn same_value_zero(a: &Value, b: &Value) -> bool {
 fn iter_elements(v: &Value) -> Vec<Value> {
     match v {
         Value::Array(a) => a.borrow().iter().cloned().collect(),
-        Value::NumberArray(a) => a.borrow().iter().map(|n| Value::Number(*n)).collect(),
+        Value::NumberArray(a) => a.borrow().to_values(),
         _ => Vec::new(),
     }
 }

package/crates/tish_builtins/src/construct.rs

@@ -1,7 +1,13 @@
 //! `new` lowering for non-JS targets: `construct(callee, args)` approximates JS `[[Construct]]`.
 //! Browser-exact behavior remains on `tish build --target js`.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectMap, Value, VmRef};
 
 const CONSTRUCT: &str = "__construct";

package/crates/tish_builtins/src/date.rs

@@ -11,7 +11,13 @@
 //! is no timezone database in the core builtins (keeps them lean + wasm-friendly). `getTime`,
 //! `valueOf`, the `getUTC*` family and `toISOString` are therefore fully deterministic everywhere.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectMap, Value, VmRef};
 
 const CONSTRUCT: &str = "__construct";
@@ -23,6 +29,7 @@ const MONTHS: [&str; 12] = [
 ];
 
 /// Current wall-clock time as epoch milliseconds.
+#[cfg(not(feature = "portable"))]
 fn now_ms() -> f64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
@@ -30,6 +37,13 @@ fn now_ms() -> f64 {
         .unwrap_or(0.0)
 }
 
+/// No OS clock on GBA: read the runtime-installed clock hook (defaults to 0 until
+/// the facade wires up an agb timer). See `tishlang_core::install_clock`.
+#[cfg(feature = "portable")]
+fn now_ms() -> f64 {
+    tishlang_core::now_ms()
+}
+
 /// A `(method name, field extractor)` pair for the numeric `Date` getters. The explicit
 /// `fn(&Civil) -> i64` coerces the (non-capturing) extractor closures to a single fn-pointer type so
 /// they can live in one array.

package/crates/tish_builtins/src/globals.rs

@@ -3,7 +3,13 @@
 //! Used by both tishlang_vm (bytecode) and tishlang_runtime (compiled). Keeps tishlang_vm
 //! independent of tishlang_runtime.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
+use tishlang_core::Arc;
 use tishlang_core::VmRef;
 use tishlang_core::{percent_decode, percent_decode_component, percent_encode, percent_encode_component, ObjectMap, Value};
 
@@ -79,7 +85,7 @@ pub fn array_from(args: &[Value]) -> Value {
     let source = args.first().cloned().unwrap_or(Value::Null);
     let items: Vec<Value> = match &source {
         Value::Array(a) => a.borrow().clone(),
-        Value::NumberArray(a) => a.borrow().iter().map(|n| Value::Number(*n)).collect(),
+        Value::NumberArray(a) => a.borrow().to_values(),
         // `drain_iterator` covers String (chars), Set/Map, and any iterator object.
         other => {
             if let Some(d) = tishlang_core::drain_iterator(other) {
@@ -296,6 +302,25 @@ pub fn string_from_char_code(args: &[Value]) -> Value {
     Value::String(s.into())
 }
 
+/// Object.freeze(obj) — mark the object frozen so later property writes throw a catchable
+/// TypeError (#437). Returns the same object; non-objects pass through unchanged (JS semantics).
+pub fn object_freeze(args: &[Value]) -> Value {
+    if let Some(Value::Object(obj)) = args.first() {
+        obj.borrow_mut().frozen = true;
+    }
+    args.first().cloned().unwrap_or(Value::Null)
+}
+
+/// Object.isFrozen(obj) — true if the object was frozen. Primitives are considered frozen (JS).
+pub fn object_is_frozen(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Object(obj)) => Value::Bool(obj.borrow().frozen),
+        // Arrays are mutable and not freezable in this slice → not frozen; other primitives are.
+        Some(Value::Array(_)) => Value::Bool(false),
+        _ => Value::Bool(true),
+    }
+}
+
 /// Object.keys(obj)
 pub fn object_keys(args: &[Value]) -> Value {
     match args.first() {
@@ -319,12 +344,33 @@ pub fn object_keys(args: &[Value]) -> Value {
                 .collect();
             Value::Array(VmRef::new(keys))
         }
+        // A packed `NumberArray` has the same own enumerable keys (its index strings) — without
+        // this, `for (k in arr)` (lowered to `for-of Object.keys`) enumerated NOTHING under
+        // TISH_PACKED_ARRAYS=1. Mirrors the Array arm.
+        Some(Value::NumberArray(arr)) => {
+            let len = arr.borrow().len();
+            let keys: Vec<Value> = (0..len)
+                .map(|i| Value::String(tishlang_core::ArcStr::from(i.to_string().as_str())))
+                .collect();
+            Value::Array(VmRef::new(keys))
+        }
+        // A by-reference boxed typed struct (GBA/portable): materialise it to its ordered object and
+        // enumerate that, so `Object.keys(s)` / `for (k in s)` (lowered to `for-of Object.keys`) see
+        // the field names instead of nothing. (JSON/display already materialise; this closes the
+        // reflection paths so the boxed struct is enumerable exactly like the object it stands for.)
+        #[cfg(feature = "portable")]
+        Some(Value::Struct(s)) => object_keys(&[s.borrow().tish_to_object()]),
         _ => Value::Array(VmRef::new(Vec::new())),
     }
 }
 
 /// Object.values(obj)
 pub fn object_values(args: &[Value]) -> Value {
+    // A boxed typed struct materialises to its ordered object first (see `object_keys`).
+    #[cfg(feature = "portable")]
+    if let Some(Value::Struct(s)) = args.first() {
+        return object_values(&[s.borrow().tish_to_object()]);
+    }
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
         let values: Vec<Value> = obj_borrow.strings.values().cloned().collect();
@@ -336,6 +382,11 @@ pub fn object_values(args: &[Value]) -> Value {
 
 /// Object.entries(obj)
 pub fn object_entries(args: &[Value]) -> Value {
+    // A boxed typed struct materialises to its ordered object first (see `object_keys`).
+    #[cfg(feature = "portable")]
+    if let Some(Value::Struct(s)) = args.first() {
+        return object_entries(&[s.borrow().tish_to_object()]);
+    }
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
         let entries: Vec<Value> = obj_borrow
@@ -372,6 +423,17 @@ pub fn object_assign(args: &[Value]) -> Value {
     target_mut.strings.reserve(additional_capacity);
 
     for source in args.iter().skip(1) {
+        // A boxed typed struct source materialises to its ordered object first (GBA/portable), so
+        // `Object.assign(t, s)` copies its fields instead of silently skipping it (see `object_keys`).
+        #[cfg(feature = "portable")]
+        let struct_obj;
+        #[cfg(feature = "portable")]
+        let source: &Value = if let Value::Struct(s) = source {
+            struct_obj = s.borrow().tish_to_object();
+            &struct_obj
+        } else {
+            source
+        };
         if let Value::Object(src) = source {
             let src_borrow = src.borrow();
             for (k, v) in src_borrow.strings.iter() {
@@ -495,7 +557,7 @@ pub fn js_parse_float(s: &str) -> f64 {
 pub fn object_from_entries(args: &[Value]) -> Value {
     if let Some(Value::Array(entries)) = args.first() {
         let entries_borrow = entries.borrow();
-        let mut obj: ObjectMap = ObjectMap::with_capacity(entries_borrow.len());
+        let mut obj: ObjectMap = ObjectMap::with_capacity_and_hasher(entries_borrow.len(), Default::default());
 
         for entry in entries_borrow.iter() {
             if let Value::Array(pair) = entry {

package/crates/tish_builtins/src/helpers.rs

@@ -1,6 +1,10 @@
 //! Common helper functions used across builtin implementations.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectMap, Value};
 
 /// Normalize an array index, handling negative indices.
@@ -20,8 +24,8 @@ pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
 }
 
 /// Create an error object with a single "error" field.
-pub fn make_error_value(e: impl std::fmt::Display) -> Value {
-    let mut obj = ObjectMap::with_capacity(1);
+pub fn make_error_value(e: impl core::fmt::Display) -> Value {
+    let mut obj = ObjectMap::with_capacity_and_hasher(1, Default::default());
     obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
     Value::object(obj)
 }

package/crates/tish_builtins/src/iterator.rs

@@ -12,7 +12,11 @@
 //! array-returning version behaved; mid-iteration mutation of the source is not reflected (a
 //! live iterator is a follow-up).
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
+use tishlang_core::Arc;
 
 use tishlang_core::{ObjectMap, Value, VmRef};
 

package/crates/tish_builtins/src/lib.rs

@@ -3,6 +3,9 @@
 //! Used by the compiled runtime (tishlang_runtime) and bytecode VM (tishlang_vm). The
 //! interpreter (tishlang_eval) implements builtins inline due to different Value
 //! and native signatures.
+#![cfg_attr(feature = "portable", no_std)]
+
+extern crate alloc;
 
 pub mod array;
 pub mod collections;

package/crates/tish_builtins/src/math.rs

@@ -1,5 +1,11 @@
 //! Math builtin functions.
 
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
 use crate::helpers::extract_num;
 use tishlang_core::{to_int32, to_uint32, Value};
 
@@ -120,10 +126,18 @@ pub fn pow(args: &[Value]) -> Value {
     Value::Number(base.powf(exp))
 }
 
+#[cfg(not(feature = "portable"))]
 pub fn random(_args: &[Value]) -> Value {
     Value::Number(rand::random::<f64>())
 }
 
+/// No OS entropy on GBA: read the runtime-installed RNG hook (a seedable xorshift
+/// fallback until the facade wires up `agb::rng`). See `tishlang_core::install_rng`.
+#[cfg(feature = "portable")]
+pub fn random(_args: &[Value]) -> Value {
+    Value::Number(tishlang_core::random_f64())
+}
+
 pub fn sign(args: &[Value]) -> Value {
     let n = extract_num(args.first()).unwrap_or(f64::NAN);
     Value::Number(if n.is_nan() {