@tishlang/tish-lsp 2.38.0 → 2.43.8

package/Cargo.toml

@@ -36,7 +36,10 @@ members = [
 ]
 # Generated native-build projects (`tish build`) land under `target/` when TMPDIR points there;
 # never enroll anything beneath `target/` as a workspace member.
-exclude = ["target"]
+# GBA-only: depends on `agb`, which builds solely for thumbv4t. Excluded so host
+# `cargo build` doesn't try to cross-compile it; built explicitly with the target
+# (and consumed by path from generated GBA projects, not as a workspace member).
+exclude = ["target", "crates/tish_runtime_gba"]
 resolver = "2"
 
 [workspace.package]

package/crates/tish/src/cli_help.rs

@@ -557,6 +557,12 @@ pub(crate) struct BuildArgs {
     pub crate_type: String,
     #[arg(long, help_heading = "Options")]
     pub no_optimize: bool,
+    /// Platform for RN-style module resolution (`macos`, `ios`, `windows`, `linux`, `web`).
+    #[arg(long, value_name = "NAME", help_heading = "Options")]
+    pub platform: Option<String>,
+    /// Surface for module resolution: `native`, `webview`, or `web` (also `TISH_SURFACE`).
+    #[arg(long, value_name = "NAME", help_heading = "Options")]
+    pub surface: Option<String>,
     /// For `--target js` project builds: emit `OUTPUT.js.map` and `//# sourceMappingURL=…` so JS/TS tools can jump to original `.tish` (implies `--no-optimize` for that build).
     #[arg(long, help_heading = "Options")]
     pub source_map: bool,
@@ -599,6 +605,12 @@ pub(crate) struct CompileModuleArgs {
     /// Project root for resolving bare specifiers / `node_modules` (defaults to the file's parent).
     #[arg(long, value_name = "DIR", help_heading = "Options")]
     pub project_root: Option<String>,
+    /// Platform for RN-style module resolution (`macos`, `ios`, `windows`, `linux`, `web`).
+    #[arg(long, value_name = "NAME", help_heading = "Options")]
+    pub platform: Option<String>,
+    /// Surface for module resolution: `native`, `webview`, or `web`.
+    #[arg(long, value_name = "NAME", help_heading = "Options")]
+    pub surface: Option<String>,
     /// Disable AST optimizations (forced on when a source map is emitted).
     #[arg(long, help_heading = "Options")]
     pub no_optimize: bool,
@@ -626,6 +638,22 @@ pub(crate) enum Commands {
     /// Compile a single `.tish` module to one ES module (for Vite dev / HMR); prints to stdout
     #[command(name = "compile-module")]
     CompileModule(CompileModuleArgs),
+    /// Resolve a relative `.tish` import with platform/surface cascade (for Vite / tooling)
+    #[command(name = "resolve-id")]
+    ResolveId {
+        /// Import specifier (must be relative, e.g. `./Button` or `./Button.tish`).
+        #[arg(required = true, value_name = "SOURCE", help_heading = "Arguments")]
+        source: String,
+        /// Absolute path of the importing file (directory used as resolve base).
+        #[arg(long, value_name = "FILE", help_heading = "Options")]
+        importer: Option<String>,
+        /// Platform token (`macos`, `ios`, `windows`, `linux`, `web`).
+        #[arg(long, value_name = "NAME", help_heading = "Options")]
+        platform: Option<String>,
+        /// Surface token (`native`, `webview`, `web`).
+        #[arg(long, value_name = "NAME", help_heading = "Options")]
+        surface: Option<String>,
+    },
     /// Parse and dump AST
     #[command(name = "dump-ast")]
     DumpAst {

package/crates/tish/src/main.rs

@@ -73,7 +73,8 @@ fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
 fn argv_with_implicit_run(mut argv: Vec<String>) -> Vec<String> {
     if argv.len() >= 2 {
         let first = argv[1].as_str();
-        const SUBCOMMANDS: &[&str] = &["run", "repl", "build", "compile-module", "dump-ast"];
+        const SUBCOMMANDS: &[&str] =
+            &["run", "repl", "build", "compile-module", "resolve-id", "dump-ast"];
         let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.contains(&first);
         if looks_like_file {
             argv.insert(1, "run".to_string());
@@ -126,6 +127,13 @@ fn main() {
             if let Some(mode) = &a.check {
                 std::env::set_var("TISH_CHECK", mode);
             }
+            if let Err(e) = tishlang_compile::apply_resolve_env(
+                a.platform.as_deref(),
+                a.surface.as_deref(),
+            ) {
+                eprintln!("Error: {}", e);
+                std::process::exit(1);
+            }
             build_file(
                 &a.file,
                 &a.output,
@@ -140,7 +148,30 @@ fn main() {
                 &a.jsx_import_source,
             )
         }
-        Some(Commands::CompileModule(a)) => compile_module(&a),
+        Some(Commands::CompileModule(a)) => {
+            if let Err(e) = tishlang_compile::apply_resolve_env(
+                a.platform.as_deref(),
+                a.surface.as_deref(),
+            ) {
+                eprintln!("Error: {}", e);
+                std::process::exit(1);
+            }
+            compile_module(&a)
+        }
+        Some(Commands::ResolveId {
+            source,
+            importer,
+            platform,
+            surface,
+        }) => tishlang_compile::resolve_id_public(
+            &source,
+            importer.as_deref(),
+            platform.as_deref(),
+            surface.as_deref(),
+        )
+        .map(|path| {
+            println!("{path}");
+        }),
         Some(Commands::DumpAst {
             file,
             ignore_indent,
@@ -883,9 +914,9 @@ fn build_file(
         .map_err(|e| e.to_string());
     }
 
-    if target != "native" {
+    if target != "native" && target != "gba" {
         return Err(format!(
-            "Unknown target: {}. Use 'native', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
+            "Unknown target: {}. Use 'native', 'gba', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
             target
         ));
     }
@@ -899,7 +930,12 @@ fn build_file(
     });
     let features: Vec<String> = native_build_features_from_cli(cli_features);
 
-    let build_config = if let Some(triple) = ios_triple {
+    let build_config = if target == "gba" {
+        if is_js {
+            return Err("tish build --target gba requires a .tish entry file.".to_string());
+        }
+        tishlang_native::NativeBuildConfig::gba()
+    } else if let Some(triple) = ios_triple {
         tishlang_native::NativeBuildConfig::ios_staticlib(triple)
     } else if crate_type == "staticlib" {
         tishlang_native::NativeBuildConfig {

package/crates/tish/tests/scope_merge.rs

@@ -0,0 +1,79 @@
+//! Regression for #38: a merged `@scope/pkg` package (declared via `tish.module`, `exports.tish`,
+//! etc.) must resolve as merged **Tish source**, not be routed to the native Rust-crate path (which
+//! would reject it with "not a Tish native module" or mis-treat it as a crate). Native `@scope`
+//! crates (marked with `tish.crate` / `tish.rustDependencies`) remain native and are exercised by
+//! the downstream regression (tish-apple/tish-macos).
+
+use std::fs;
+
+use tishlang_ast::{Expr, Statement};
+use tishlang_compile::{merge_modules, resolve_project};
+
+/// Build a tempdir project whose `main.tish` imports a merged `@test/greet` package. `tish_field`
+/// is the extra package.json snippet declaring how the package presents itself (`,"tish":{…}` etc.).
+fn setup(tish_field: &str) -> tempfile::TempDir {
+    let dir = tempfile::tempdir().unwrap();
+    let root = dir.path();
+    let pkg = root.join("node_modules/@test/greet");
+    fs::create_dir_all(&pkg).unwrap();
+    fs::write(
+        pkg.join("package.json"),
+        format!(r#"{{"name":"@test/greet","version":"1.0.0"{tish_field}}}"#),
+    )
+    .unwrap();
+    fs::write(pkg.join("index.tish"), "export fn greet() { return \"hi\" }\n").unwrap();
+    fs::write(
+        root.join("main.tish"),
+        "import { greet } from \"@test/greet\"\nconsole.log(greet())\n",
+    )
+    .unwrap();
+    dir
+}
+
+fn assert_merged_as_source(dir: &tempfile::TempDir) {
+    let root = dir.path();
+    let modules = resolve_project(&root.join("main.tish"), Some(root)).expect("resolve");
+    let merged = merge_modules(modules).expect("merge");
+    // Merged as source ⇒ the package's `greet` fn is folded into the top-level program.
+    let has_greet = merged
+        .program
+        .statements
+        .iter()
+        .any(|s| matches!(s, Statement::FunDecl { name, .. } if name.as_ref() == "greet"));
+    assert!(
+        has_greet,
+        "merged @scope package's fn must be folded into the program (merged as Tish source)"
+    );
+    // ...and NOT lowered to a native module load (the #38 mis-routing).
+    let native_scope = merged.program.statements.iter().any(|s| {
+        matches!(
+            s,
+            Statement::VarDecl { init: Some(Expr::NativeModuleLoad { spec, .. }), .. }
+            if spec.contains("@test")
+        )
+    });
+    assert!(
+        !native_scope,
+        "a merged @scope package must NOT be routed to the native Rust-crate path (#38)"
+    );
+}
+
+#[test]
+fn scope_tish_module_true_merges_as_source() {
+    assert_merged_as_source(&setup(r#","tish":{"module":true}"#));
+}
+
+#[test]
+fn scope_tish_module_string_path_merges_as_source() {
+    assert_merged_as_source(&setup(r#","tish":{"module":"index.tish"}"#));
+}
+
+#[test]
+fn scope_exports_tish_merges_as_source() {
+    assert_merged_as_source(&setup(r#","exports":{"tish":"./index.tish"}"#));
+}
+
+#[test]
+fn scope_plain_main_merges_as_source() {
+    assert_merged_as_source(&setup(r#","main":"index.tish""#));
+}

package/crates/tish_build_utils/src/lib.rs

@@ -340,7 +340,22 @@ pub fn find_crate_path(crate_name: &str) -> Result<PathBuf, String> {
 
 /// Sanitize a user-chosen output stem for Cargo `[lib]` / `[[bin]]` target names.
 pub fn cargo_target_name(stem: &str) -> String {
-    stem.replace('-', "_")
+    // The result is emitted verbatim into a generated `Cargo.toml` (`name = "<stem>"`) and used as
+    // the crate/target name, so it must be a valid Rust identifier. Map every char that isn't
+    // ASCII-alphanumeric or `_` to `_` — a `-` (cargo normalizes it to `_` anyway), but also a `.`,
+    // space, or `"` from an odd `-o` path, which would otherwise break or inject the manifest.
+    // A leading digit is prefixed with `_`; an empty result falls back to a fixed default.
+    let mut name: String = stem
+        .chars()
+        .map(|c| if c.is_ascii_alphanumeric() || c == '_' { c } else { '_' })
+        .collect();
+    if name.is_empty() {
+        return "tish_output".to_string();
+    }
+    if name.starts_with(|c: char| c.is_ascii_digit()) {
+        name.insert(0, '_');
+    }
+    name
 }
 
 /// Create a temp build directory with src subdir.
@@ -428,6 +443,17 @@ mod protoc_tests {
         assert_eq!(cargo_target_name("hello-ios"), "hello_ios");
         assert_eq!(cargo_target_name("tish_out"), "tish_out");
     }
+
+    #[test]
+    fn cargo_target_name_sanitizes_invalid_chars() {
+        // Quotes / dots / spaces from an odd `-o` stem can't break or inject the manifest.
+        assert_eq!(cargo_target_name("a\"b"), "a_b");
+        assert_eq!(cargo_target_name("my.app"), "my_app");
+        assert_eq!(cargo_target_name("my game"), "my_game");
+        // A leading digit is made identifier-safe; empty falls back.
+        assert_eq!(cargo_target_name("3d"), "_3d");
+        assert_eq!(cargo_target_name(""), "tish_output");
+    }
 }
 
 /// Find the built static library in target/release (or target/$TRIPLE/release).

package/crates/tish_builtins/Cargo.toml

@@ -8,15 +8,23 @@ description = "Shared builtin implementations for Tish (array, string, object, m
 license-file = { workspace = true }
 repository = { workspace = true }
 [dependencies]
-ahash = "0.8.11"
-indexmap = "2"
-rand = "0.10.1"
-unicode-normalization = "0.1.25"
-tishlang_core = { path = "../tish_core", version = ">=0.1" }
+# std-only deps, optional so the `portable` build drops them (rand needs OS
+# entropy; ahash needs atomics — both replaced by tishlang_core hooks/FxHasher).
+ahash = { version = "0.8.11", optional = true }
+indexmap = { version = "2", default-features = false }
+rand = { version = "0.10.1", optional = true }
+# default-features=false keeps it no_std (it works on core+alloc via tinyvec);
+# tish only uses NFC/NFD/NFKC/NFKD, none of which need std.
+unicode-normalization = { version = "0.1.25", default-features = false }
+tishlang_core = { path = "../tish_core", version = ">=0.1", default-features = false }
 
 [features]
-default = []
+default = ["std"]
+std = ["tishlang_core/std", "dep:ahash", "dep:rand"]
 regex = ["tishlang_core/regex"]
+# no_std + alloc build for GBA. Inherits tishlang_core's portable vocabulary and
+# its clock/RNG hooks; float math routes through tishlang_core::FloatExt (libm).
+portable = ["tishlang_core/portable"]
 # Propagate the `send-values` feature from `tishlang_core` so that closures
 # handed to us via `NativeFn` pick up the `Send + Sync` bound automatically
 # when multi-threaded `Value`s are enabled upstream.

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"),
+        }
+    }
 }