@tishlang/tish-format 2.43.8 → 3.0.0

package/crates/tish_core/src/value.rs

@@ -165,6 +165,35 @@ pub trait TishOpaque {
     fn as_any(&self) -> &dyn core::any::Any;
 }
 
+/// A typed native struct (from an `interface` / typed object literal in native codegen) carried inside
+/// a [`Value::Struct`] WITHOUT serialising to a hashmap object. Each generated `TishStruct_*` implements
+/// it: a boxed function that returns/passes a typed struct keeps it by reference, property access
+/// dispatches here (a small `match` on the field name — no string hash, no allocation), and it
+/// materialises to a real `Value::Object` only when a boxed `Value::Struct` (a struct whose static
+/// type was erased) crosses into genuinely dynamic territory (`JSON.stringify`, display,
+/// `Object.keys`/`values`/`entries`, `for..in`, `in`, `Object.assign`, object-literal spread `{...s}`).
+/// This is the RUNTIME fallback: when the struct's static type IS known at a reflection site, GBA
+/// codegen lowers `Object.keys`/`values`/`entries`/`in`/`{...s}` to native field reads instead — the
+/// struct is never boxed and this materialisation never runs. No `Send + Sync` bound: the `Value::Struct` variant is
+/// `cfg(portable)` and `portable` excludes `send-values` (they are mutually exclusive), so the ref is
+/// single-threaded `Rc` — mirroring the single-threaded [`TishOpaque`].
+pub trait TishStruct {
+    /// Read a field as a boxed `Value` (`Null` if `key` is not a field). Backs `get_prop`.
+    fn tish_get(&self, key: &str) -> Value;
+    /// Write a field from a boxed `Value` (no-op if `key` is not a field). Backs `set_prop`.
+    fn tish_set(&mut self, key: &str, value: Value);
+    /// Materialise an ordered `Value::Object` copy (field-declaration order, JS insertion order). Used
+    /// for JSON / display / `Object`-interop, and as the non-portable `Value::from_struct` fallback so
+    /// off-GBA backends behave EXACTLY as the historical `object_from_pairs` boundary did.
+    fn tish_to_object(&self) -> Value;
+    /// `typeof` result — always "object".
+    fn tish_type_name(&self) -> &'static str {
+        "object"
+    }
+    /// Downcast hook — recover the concrete `TishStruct_*` (e.g. for a future typed fast path).
+    fn as_any(&self) -> &dyn core::any::Any;
+}
+
 /// Trait for Promise-like values that can be awaited (block until settled).
 /// Implemented by the runtime for native compile; interpreter uses its own Promise.
 pub trait TishPromise: Send + Sync {
@@ -467,8 +496,24 @@ pub enum Value {
     Promise(Arc<dyn TishPromise>),
     /// Opaque handle to a native Rust type (e.g. Polars DataFrame).
     Opaque(Arc<dyn TishOpaque>),
+    /// A typed native struct carried BY REFERENCE (portable / GBA native codegen). Lets a boxed
+    /// function return or pass a typed struct without serialising it to a hashmap `Object` —
+    /// property access dispatches through [`TishStruct`] (a small match, no hash lookup / alloc), and
+    /// it materialises to an `Object` only on JSON / display / `Object.keys`-family / `for..in` /
+    /// `in` / `Object.assign` / `{...s}` spread. Built via
+    /// [`Value::from_struct`]. Portable-only: the ref is a single-threaded `Rc<RefCell<dyn …>>` and
+    /// `portable` excludes `send-values`, so this never violates `Send` (which off-portable `Value`
+    /// may need). A fat pointer is 16 B, so the 24 B `Value` size guard still holds.
+    #[cfg(feature = "portable")]
+    Struct(StructRef),
 }
 
+/// Reference to a boxed typed struct: `Rc<RefCell<dyn TishStruct>>`. Portable-only (see [`TishStruct`]
+/// / [`Value::Struct`]). `RefCell` is OUTSIDE the trait object so `set_prop` can borrow it mutably; the
+/// `Rc<RefCell<Concrete>> → Rc<RefCell<dyn TishStruct>>` unsizing is a stable coercion (no nightly).
+#[cfg(feature = "portable")]
+pub type StructRef = alloc::rc::Rc<core::cell::RefCell<dyn TishStruct>>;
+
 // Size guard. `Value` is 24 bytes: `String` is thin (`ArcStr`, 8B), but `Function`/`Promise`/`Opaque`
 // are fat `Arc<dyn …>` (data+vtable, 16B) ⇒ 16B payload + discriminant = 24.
 //
@@ -513,6 +558,8 @@ pub enum ValueTag {
     RegExp,
     Promise,
     Opaque,
+    #[cfg(feature = "portable")]
+    Struct,
 }
 
 /// Borrowed view of a [`Value`]'s payload, mirroring the enum variants. Lets call sites
@@ -533,6 +580,8 @@ pub enum ValueRef<'a> {
     RegExp(&'a VmRef<TishRegExp>),
     Promise(&'a Arc<dyn TishPromise>),
     Opaque(&'a Arc<dyn TishOpaque>),
+    #[cfg(feature = "portable")]
+    Struct(&'a StructRef),
 }
 
 impl Value {
@@ -578,6 +627,8 @@ impl Value {
             Value::RegExp(r) => ValueRef::RegExp(r),
             Value::Promise(p) => ValueRef::Promise(p),
             Value::Opaque(o) => ValueRef::Opaque(o),
+            #[cfg(feature = "portable")]
+            Value::Struct(s) => ValueRef::Struct(s),
         }
     }
 
@@ -598,6 +649,8 @@ impl Value {
             Value::RegExp(_) => ValueTag::RegExp,
             Value::Promise(_) => ValueTag::Promise,
             Value::Opaque(_) => ValueTag::Opaque,
+            #[cfg(feature = "portable")]
+            Value::Struct(_) => ValueTag::Struct,
         }
     }
 
@@ -1256,6 +1309,8 @@ impl core::fmt::Debug for Value {
             ),
             Value::Promise(_) => write!(f, "Promise"),
             Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
+            #[cfg(feature = "portable")]
+            Value::Struct(s) => write!(f, "Struct({})", s.borrow().tish_type_name()),
         }
     }
 }
@@ -1466,6 +1521,9 @@ impl Value {
             Value::Function(_) => "[Function]".to_string(),
             Value::Promise(_) => "[object Promise]".to_string(),
             Value::Opaque(o) => format!("[object {}]", o.type_name()),
+            // Display a boxed struct like the object it is (materialise once, then reuse the Object path).
+            #[cfg(feature = "portable")]
+            Value::Struct(s) => s.borrow().tish_to_object().to_display_string_guarded(ancestors),
             #[cfg(feature = "regex")]
             Value::RegExp(re) => {
                 let re = re.borrow();
@@ -1517,6 +1575,8 @@ impl Value {
                 .collect::<Vec<_>>()
                 .join(","),
             Value::Object(_) => "[object Object]".to_string(),
+            #[cfg(feature = "portable")]
+            Value::Struct(_) => "[object Object]".to_string(),
             // ECMAScript ToString of a number (drops `-0`'s sign), distinct from the inspect form
             // that `to_display_string` would give for `-0`. (#247)
             Value::Number(n) => js_number_to_string(*n),
@@ -1561,6 +1621,10 @@ impl Value {
             (Value::Promise(a), Value::Promise(b)) => Arc::ptr_eq(a, b),
             (Value::Opaque(a), Value::Opaque(b)) => Arc::ptr_eq(a, b),
             (Value::Symbol(a), Value::Symbol(b)) => Arc::ptr_eq(a, b),
+            // Struct-Value identity is `Rc` pointer equality, exactly like `Object` — two distinct
+            // boxings compare unequal, but a struct aliased through one `Value` is `=== ` itself.
+            #[cfg(feature = "portable")]
+            (Value::Struct(a), Value::Struct(b)) => alloc::rc::Rc::ptr_eq(a, b),
             _ => false,
         }
     }
@@ -1613,6 +1677,63 @@ impl Value {
         }))
     }
 
+    /// Box a typed native struct (a generated `TishStruct_*`). On portable (GBA) it is kept BY
+    /// REFERENCE as a cheap [`Value::Struct`] — one `Rc` allocation, no per-field string keys / hashmap;
+    /// property access later dispatches through [`TishStruct`]. On every other backend it serialises to
+    /// an ordered `Value::Object` (via [`TishStruct::tish_to_object`]) — byte-identical to the historical
+    /// `object_from_pairs` boundary, so off-GBA behaviour is unchanged. Codegen's struct-to-`Value`
+    /// boxing emits a single `Value::from_struct(..)` call for all native targets.
+    #[cfg(feature = "portable")]
+    #[inline]
+    pub fn from_struct<T: TishStruct + 'static>(v: T) -> Value {
+        Value::Struct(alloc::rc::Rc::new(core::cell::RefCell::new(v)))
+    }
+    /// See the portable variant above — off-GBA this is exactly the old `object_from_pairs` boundary.
+    #[cfg(not(feature = "portable"))]
+    #[inline]
+    pub fn from_struct<T: TishStruct>(v: T) -> Value {
+        v.tish_to_object()
+    }
+
+    /// Box a typed native struct BY SHARED REFERENCE — the boxing path codegen actually emits, so the
+    /// whole-struct clone is paid ONLY where it's genuinely needed. On portable (GBA) the struct must
+    /// be OWNED by the `Rc`, so it clones (identical to `from_struct((v).clone())`). Off-GBA it
+    /// serialises the borrow directly via [`TishStruct::tish_to_object`] with NO whole-struct clone —
+    /// byte-identical to the historical `object_from_pairs` boundary that read fields straight off the
+    /// place (#565: the old `from_struct((v).clone())` cloned the entire struct just to serialise it).
+    #[cfg(feature = "portable")]
+    #[inline]
+    pub fn from_struct_ref<T: TishStruct + Clone + 'static>(v: &T) -> Value {
+        Value::Struct(alloc::rc::Rc::new(core::cell::RefCell::new(v.clone())))
+    }
+    /// See the portable variant — off-GBA this serialises the borrow with no whole-struct clone.
+    #[cfg(not(feature = "portable"))]
+    #[inline]
+    pub fn from_struct_ref<T: TishStruct>(v: &T) -> Value {
+        v.tish_to_object()
+    }
+
+    /// If this value is a by-reference boxed struct of concrete type `T` (a `Value::Struct`), return a
+    /// CLONE of it — the native fast path for `let x: T = <boxed struct return>`, so subsequent field
+    /// reads are plain Rust loads instead of `get_prop`. Portable only: off-GBA there is no `Value::Struct`
+    /// variant, so this is always `None` and codegen's `from_value_expr` falls back to the field-by-field
+    /// `get_prop` rebuild (which also handles a genuine `Value::Object`). Returns `None` for any non-struct
+    /// value or a struct of a different concrete type.
+    #[cfg(feature = "portable")]
+    #[inline]
+    pub fn downcast_struct<T: TishStruct + Clone + 'static>(&self) -> Option<T> {
+        match self {
+            Value::Struct(s) => s.borrow().as_any().downcast_ref::<T>().cloned(),
+            _ => None,
+        }
+    }
+    /// See the portable variant — off-GBA there is no struct variant, so always `None`.
+    #[cfg(not(feature = "portable"))]
+    #[inline]
+    pub fn downcast_struct<T: TishStruct + Clone + 'static>(&self) -> Option<T> {
+        None
+    }
+
     /// Create an empty array Value.
     pub fn empty_array() -> Self {
         Value::Array(VmRef::new(Vec::new()))
@@ -1700,6 +1821,8 @@ impl Value {
             Value::Promise(_) => "object",
             Value::Opaque(o) => o.type_name(),
             Value::Symbol(_) => "symbol",
+            #[cfg(feature = "portable")]
+            Value::Struct(_) => "object",
         }
     }
 

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "2.43.8"
+version = "3.0.0"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/crates/tish_runtime/src/lib.rs

@@ -16,6 +16,7 @@ pub use tishlang_core::ObjectMap;
 // pass) instead of materializing an intermediate `AHashMap` and rebuilding from it.
 pub use tishlang_core::{ObjectData, PropMap};
 pub use tishlang_core::Value;
+pub use tishlang_core::TishStruct;
 pub use tishlang_core::NumArrayBacking;
 pub use tishlang_core::ArcStr;
 /// Used by native codegen for `f()` / `obj()` dispatch (`Value::Function` or `__call` on objects).

package/crates/tish_runtime_gba/src/lib.rs

@@ -17,8 +17,8 @@ use alloc::vec::Vec;
 // ── Core value vocabulary (single source of truth in tishlang_core) ──────────
 pub use tishlang_core::{
     js_number_to_string_into, to_int32, to_int32_value, to_number_value, to_uint32,
-    to_uint32_value, ArcStr, NumArrayBacking, ObjectData, ObjectMap, PropMap, Value, VmReadGuard,
-    VmRef, VmWriteGuard,
+    to_uint32_value, ArcStr, NumArrayBacking, ObjectData, ObjectMap, PropMap, TishStruct, Value,
+    VmReadGuard, VmRef, VmWriteGuard,
 };
 /// `Arc` on GBA is `Rc` (single-core). Emitted code writes `Arc::from(..)`.
 pub use tishlang_core::Arc;
@@ -112,10 +112,32 @@ pub fn in_operator(key: &Value, obj: &Value) -> Value {
         Value::Object(_) => Value::Bool(tishlang_core::object_has(obj, key)),
         Value::Array(arr) => Value::Bool(array_in(key, arr.borrow().len())),
         Value::NumberArray(arr) => Value::Bool(array_in(key, arr.borrow().len())),
+        // A by-reference boxed typed struct: `"field" in s` materialises to the struct's object and
+        // asks it, so a boxed struct answers `in` like the object it stands for (was always `false`).
+        Value::Struct(s) => {
+            Value::Bool(tishlang_core::object_has(&s.borrow().tish_to_object(), key))
+        }
         _ => Value::Bool(false),
     }
 }
 
+/// Spread source for `{ ...v }` (GBA emit only — codegen calls this from the Gba object-spread
+/// lowering). Returns the source's own string-keyed props as an owned `PropMap`: a boxed typed struct
+/// is materialised to its ordered object first, so `{ ...s }` carries the struct's fields instead of
+/// dropping them; a non-object yields `None` (spread of `null`/a number contributes nothing, per JS).
+/// Desktop emit keeps its inline `if let Value::Object` path, so this GBA-only helper adds no
+/// non-GBA cost.
+pub fn object_spread_props(v: &Value) -> Option<PropMap> {
+    match v {
+        Value::Object(o) => Some(o.borrow().strings.clone()),
+        Value::Struct(s) => match s.borrow().tish_to_object() {
+            Value::Object(o) => Some(o.borrow().strings.clone()),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
 fn array_in(key: &Value, len: usize) -> bool {
     let key_str: Arc<str> = match key {
         Value::String(s) => Arc::from(s.as_str()),
@@ -175,6 +197,9 @@ pub fn get_prop(obj: &Value, key: impl AsRef<str>) -> Value {
             }
         }
         Value::Opaque(o) => o.get_method(key).map(Value::Function).unwrap_or(Value::Null),
+        // A boxed typed struct: read the field natively (a small match, no hashmap). `size`/method
+        // sugar isn't relevant here — structs are plain field bags.
+        Value::Struct(s) => s.borrow().tish_get(key),
         Value::Null => {
             tishlang_core::set_pending_throw(tishlang_core::cannot_read_property_error(key));
             Value::Null
@@ -222,6 +247,13 @@ pub fn get_index(obj: &Value, index: &Value) -> Value {
             _ => Value::Null,
         },
         Value::Object(_) => tishlang_core::object_get(obj, index).unwrap_or(Value::Null),
+        Value::Struct(s) => {
+            let key = match index {
+                Value::String(k) => k.to_string(),
+                other => other.to_js_string(),
+            };
+            s.borrow().tish_get(&key)
+        }
         Value::Null => {
             let key = match index {
                 Value::String(s) => s.to_string(),
@@ -322,6 +354,10 @@ pub fn set_prop(obj: &Value, key: &str, val: Value) -> Value {
             }
             val
         }
+        Value::Struct(s) => {
+            s.borrow_mut().tish_set(key, val.clone());
+            val
+        }
         _ => {
             tishlang_core::set_pending_throw(tishlang_core::type_error("Cannot assign property on a non-object"));
             val
@@ -427,6 +463,44 @@ pub fn json_stringify(args: &[Value]) -> Value {
     Value::String(tishlang_core::json_stringify(&v).into())
 }
 
+/// `json::{escape_into, write_json_number}` — the helpers codegen-emitted per-struct JSON serialisers
+/// (`__tish_json_TishStruct_*`, #315) call. The std runtime exposes these under `tishlang_runtime::json`;
+/// the GBA facade must mirror them so a game that uses a typed `interface`/`type` compiles. no_std.
+pub mod json {
+    pub use tishlang_core::write_json_number;
+
+    /// Append the JSON-escaped contents of `s` (no surrounding quotes) to `buf`. Same escape rules as
+    /// the std runtime's `json::escape_into`; kept local (uses `core::fmt::Write` for `\uXXXX`).
+    pub fn escape_into(buf: &mut alloc::string::String, s: &str) {
+        use core::fmt::Write;
+        let bytes = s.as_bytes();
+        let mut start = 0usize;
+        for (i, &b) in bytes.iter().enumerate() {
+            if b < 0x20 || b == b'"' || b == b'\\' {
+                if start < i {
+                    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"),
+                    _ => {
+                        let _ = write!(buf, "\\u{:04x}", b as u32);
+                    }
+                }
+                start = i + 1;
+            }
+        }
+        if start < bytes.len() {
+            buf.push_str(&s[start..]);
+        }
+    }
+}
+
 /// Build an `ObjectMap` from an array of key/value pairs. Generated object literals
 /// emit `ObjectMap::from([...])`; hashbrown's `From<[_; N]>` isn't available with a
 /// custom hasher, so the Gba post-pass rewrites those calls to this.
@@ -529,6 +603,58 @@ pub use tishlang_builtins::globals::{
 };
 pub use tishlang_builtins::string::escape_html as string_escape_html_impl;
 
+// ── String methods (codegen lowers `.slice()`/`.indexOf()`/`.toLowerCase()`/… to these prelude
+// names). Mirrors the std `tish_runtime` wrappers; the portable subset (no regex / unicode-normalize).
+pub use tishlang_builtins::string::{
+    at as string_at_impl, char_at as string_char_at_impl,
+    char_code_at as string_char_code_at_impl, ends_with as string_ends_with_impl,
+    includes as string_includes_impl, index_of as string_index_of_impl,
+    slice as string_slice_impl, starts_with as string_starts_with_impl,
+    substr as string_substr_impl, substring as string_substring_impl,
+    to_lower_case as string_to_lower_case, to_upper_case as string_to_upper_case,
+    trim as string_trim, trim_end as string_trim_end, trim_start as string_trim_start,
+};
+#[inline]
+pub fn string_index_of(s: &Value, search: &Value, from: &Value) -> Value {
+    string_index_of_impl(s, search, Some(from))
+}
+#[inline]
+pub fn string_includes(s: &Value, search: &Value, from: &Value) -> Value {
+    string_includes_impl(s, search, Some(from))
+}
+#[inline]
+pub fn string_slice(s: &Value, start: &Value, end: &Value) -> Value {
+    string_slice_impl(s, start, end)
+}
+#[inline]
+pub fn string_substring(s: &Value, start: &Value, end: &Value) -> Value {
+    string_substring_impl(s, start, end)
+}
+#[inline]
+pub fn string_substr(s: &Value, start: &Value, length: &Value) -> Value {
+    string_substr_impl(s, start, length)
+}
+#[inline]
+pub fn string_starts_with(s: &Value, search: &Value, position: Option<&Value>) -> Value {
+    string_starts_with_impl(s, search, position)
+}
+#[inline]
+pub fn string_ends_with(s: &Value, search: &Value, end_position: Option<&Value>) -> Value {
+    string_ends_with_impl(s, search, end_position)
+}
+#[inline]
+pub fn string_char_at(s: &Value, idx: &Value) -> Value {
+    string_char_at_impl(s, idx)
+}
+#[inline]
+pub fn string_at(s: &Value, idx: &Value) -> Value {
+    string_at_impl(s, idx)
+}
+#[inline]
+pub fn string_char_code_at(s: &Value, idx: &Value) -> Value {
+    string_char_code_at_impl(s, idx)
+}
+
 // ── Constructors, collections, typed arrays, symbol (re-export as prelude names) ──
 pub use tishlang_builtins::construct::{
     array_construct, audio_context_constructor_value as tish_audio_context_constructor,
@@ -539,8 +665,66 @@ pub use tishlang_builtins::collections::{
     map_constructor_value as tish_map_constructor, map_get, map_has, map_set, map_values,
     set_constructor_value as tish_set_constructor,
 };
-// Array mutators (portable) — `.push()` / `.pop()` lower to these `array_*` names.
-pub use tishlang_builtins::array::{pop as array_pop, push as array_push};
+// Array methods — codegen lowers `.push()`/`.slice()`/`.map()`/… to these `array_*` names. Mirrors
+// the std `tish_runtime` block (minus RNG-dependent `shuffle`). Portable: all operate on Vec<Value>.
+pub use tishlang_builtins::array::{
+    at as array_at, concat as array_concat_impl, every as array_every, filter as array_filter,
+    find as array_find, find_index as array_find_index, find_last as array_find_last,
+    find_last_index as array_find_last_index, flat as array_flat_impl, flat_map as array_flat_map,
+    for_each as array_for_each, includes as array_includes_impl, index_of as array_index_of_impl,
+    join as array_join_impl, map as array_map, pop as array_pop, push as array_push_impl,
+    fill as array_fill, last_index_of as array_last_index_of, copy_within as array_copy_within,
+    reduce as array_reduce, reduce_right as array_reduce_right, reverse as array_reverse,
+    keys as array_keys, values as array_values, entries as array_entries, shift as array_shift,
+    slice as array_slice_impl, snapshot_values as array_snapshot_values,
+    as_f64_snapshot as array_as_f64_snapshot, some as array_some,
+    sort_by_keys as array_sort_by_keys, sort_default as array_sort_default,
+    sort_numeric_asc as array_sort_numeric_asc, sort_numeric_desc as array_sort_numeric_desc,
+    sort_with_comparator as array_sort_with_comparator, splice as array_splice_impl,
+    to_reversed as array_to_reversed, to_sorted as array_to_sorted,
+    to_spliced as array_to_spliced, with as array_with, unshift as array_unshift_impl,
+};
+#[inline]
+pub fn array_push(arr: &Value, args: &[Value]) -> Value { array_push_impl(arr, args) }
+#[inline]
+pub fn array_unshift(arr: &Value, args: &[Value]) -> Value { array_unshift_impl(arr, args) }
+#[inline]
+pub fn array_index_of(arr: &Value, search: &Value, from: Option<&Value>) -> Value {
+    array_index_of_impl(arr, search, from)
+}
+#[inline]
+pub fn array_includes(arr: &Value, search: &Value, from: &Value) -> Value {
+    array_includes_impl(arr, search, Some(from))
+}
+#[inline]
+pub fn array_join(arr: &Value, sep: &Value) -> Value { array_join_impl(arr, sep) }
+#[inline]
+pub fn array_splice(arr: &Value, start: &Value, delete_count: Option<&Value>, items: &[Value]) -> Value {
+    array_splice_impl(arr, start, delete_count, items)
+}
+#[inline]
+pub fn array_slice(arr: &Value, start: &Value, end: &Value) -> Value {
+    array_slice_impl(arr, start, end)
+}
+#[inline]
+pub fn array_concat(arr: &Value, args: &[Value]) -> Value { array_concat_impl(arr, args) }
+#[inline]
+pub fn array_flat(arr: &Value, depth: &Value) -> Value { array_flat_impl(arr, depth) }
+#[inline]
+pub fn array_sort(arr: &Value, comparator: Option<&Value>) -> Value {
+    match comparator {
+        Some(cmp) => array_sort_with_comparator(arr, cmp),
+        None => array_sort_default(arr),
+    }
+}
+/// `.at(i)` dispatched on the runtime value — exists on both String and Array (#247).
+#[inline]
+pub fn value_at(recv: &Value, idx: &Value) -> Value {
+    match recv {
+        Value::String(_) => string_at_impl(recv, idx),
+        _ => array_at(recv, idx),
+    }
+}
 pub use tishlang_builtins::symbol::symbol_object;
 pub use tishlang_builtins::typedarrays::{
     float32_array_constructor_value as tish_float32_array_constructor,

package/crates/tish_vm/src/vm.rs

@@ -4093,6 +4093,54 @@ fn get_member(obj: &Value, key: &Arc<str>) -> Result<Value, String> {
                         Value::NumberArray(a2.clone())
                     })
                 }
+                // #560: `copyWithin` MUTATES in place, but — unlike fill/reverse/splice — it had no
+                // packed arm, so it fell to the `_ =>` materialise-to-boxed fallback below and copied
+                // within a THROWAWAY boxed copy, leaving the packed array untouched (a silent no-op
+                // that diverged from interp). copyWithin only relocates existing elements, so the
+                // array stays packed: block-copy straight on the Vec<f64> (deopt only if already
+                // boxed). Index clamping mirrors `arr_builtins::copy_within` (`normalize_index`).
+                "copyWithin" => {
+                    let a2 = a_clone.clone();
+                    make_native_fn(move |args: &[Value]| {
+                        let len = a2.borrow().len() as i64;
+                        let norm = |v: Option<&Value>, dflt: i64| -> i64 {
+                            match v {
+                                Some(Value::Number(n)) => {
+                                    let i = *n as i64;
+                                    if i < 0 { (len + i).max(0) } else { i.min(len) }
+                                }
+                                _ => dflt,
+                            }
+                        };
+                        let target = norm(args.first(), 0) as usize;
+                        let start = norm(args.get(1), 0) as usize;
+                        let end = norm(args.get(2), len) as usize;
+                        let mut b = a2.borrow_mut();
+                        match b.as_packed_mut() {
+                            Some(nums) => {
+                                if start < end && target < nums.len() {
+                                    let count = (end - start).min(nums.len() - target);
+                                    let block: Vec<f64> = nums[start..start + count].to_vec();
+                                    for (k, val) in block.into_iter().enumerate() {
+                                        nums[target + k] = val;
+                                    }
+                                }
+                            }
+                            None => {
+                                let boxed = b.deopt();
+                                if start < end && target < boxed.len() {
+                                    let count = (end - start).min(boxed.len() - target);
+                                    let block: Vec<Value> = boxed[start..start + count].to_vec();
+                                    for (k, val) in block.into_iter().enumerate() {
+                                        boxed[target + k] = val;
+                                    }
+                                }
+                            }
+                        }
+                        drop(b);
+                        Value::NumberArray(a2.clone())
+                    })
+                }
                 "reverse" => make_native_fn(move |_: &[Value]| {
                     let mut b = a_clone.borrow_mut();
                     match b.as_packed_mut() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "2.43.8",
+  "version": "3.0.0",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {