@tishlang/tish-format 2.16.13 → 2.35.0

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

@@ -176,7 +176,12 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                     span: span_util::oxc_span_to_tish(ctx.1, &*arrow.body),
                 }))
             };
-            Ok(Expr::ArrowFunction { params, body, span })
+            Ok(Expr::ArrowFunction {
+                async_: arrow.r#async,
+                params,
+                body,
+                span,
+            })
         }
         OxcExpr::AwaitExpression(a) => Ok(Expr::Await {
             operand: Box::new(convert_expr(&a.argument, ctx)?),
@@ -229,7 +234,12 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                     }))
                 }
             };
-            Ok(Expr::ArrowFunction { params, body, span })
+            Ok(Expr::ArrowFunction {
+                async_: f.r#async,
+                params,
+                body,
+                span,
+            })
         }
         _ => Err(ConvertError::new(ConvertErrorKind::Unsupported {
             what: format!("expression: {:?}", std::mem::discriminant(expr)),

package/crates/tish/tests/fixtures/fs_parity_callbacks.tish

@@ -0,0 +1,22 @@
+// Issue #122: Node callback form on the VM — `fs.writeFile(path, data, (err) => …)` and
+// `fs.readFile(path, (err, data) => …)`, with (err, data) semantics and a non-null err on a
+// missing file. Operates under $FS_TMP.
+import { writeFile, readFile, stat, unlink } from "node:fs"
+import { process } from "tish:process"
+
+let d = process.env.FS_TMP
+writeFile(d + "/cb.txt", "callback data", (err) => {
+  console.log("write-err-null=" + String(err === null))
+  readFile(d + "/cb.txt", (err2, data) => {
+    console.log("read=" + data)
+    stat(d + "/cb.txt", (err3, st) => {
+      console.log("size=" + String(st.size) + ",file=" + String(st.isFile()))
+      unlink(d + "/cb.txt", (err4) => {
+        console.log("unlink-err-null=" + String(err4 === null))
+      })
+    })
+  })
+})
+readFile(d + "/missing.txt", (err, data) => {
+  console.log("missing-err-set=" + String(!(err === null)) + ",data-null=" + String(data === null))
+})

package/crates/tish/tests/fixtures/fs_parity_promises.tish

@@ -0,0 +1,21 @@
+// Issue #122: the async `node:fs/promises` surface — await on the same methods, and `access`
+// rejects on a missing path. Operates under $FS_TMP.
+import { writeFile, readFile, stat, mkdir, readdir, rm, access } from "node:fs/promises"
+import { process } from "tish:process"
+
+async fn main() {
+  let d = process.env.FS_TMP
+  await writeFile(d + "/p.txt", "async hello")
+  console.log("read=" + (await readFile(d + "/p.txt")))
+  let st = await stat(d + "/p.txt")
+  console.log("size=" + String(st.size))
+  await mkdir(d + "/pd")
+  await writeFile(d + "/pd/x", "x")
+  console.log("dir=" + (await readdir(d + "/pd")).join(","))
+  let rejected = false
+  try { await access(d + "/missing") } catch (e) { rejected = true }
+  console.log("access-missing-rejected=" + String(rejected))
+  await rm(d + "/pd", { recursive: true })
+  console.log("done")
+}
+main()

package/crates/tish/tests/fixtures/fs_parity_sync.tish

@@ -0,0 +1,20 @@
+// Issue #122: Node-compatible fs sync surface via `node:fs`. Operates under $FS_TMP.
+import { writeFileSync, readFileSync, existsSync, statSync, mkdirSync, readdirSync, renameSync, rmSync, appendFileSync, copyFileSync, constants } from "node:fs"
+import { process } from "tish:process"
+
+let d = process.env.FS_TMP
+writeFileSync(d + "/a.txt", "hi")
+appendFileSync(d + "/a.txt", "!")
+console.log("read=" + readFileSync(d + "/a.txt"))
+console.log("exists=" + String(existsSync(d + "/a.txt")) + "," + String(existsSync(d + "/no")))
+let st = statSync(d + "/a.txt")
+console.log("size=" + String(st.size) + ",file=" + String(st.isFile()) + ",dir=" + String(st.isDirectory()))
+mkdirSync(d + "/sub")
+copyFileSync(d + "/a.txt", d + "/sub/x.txt")
+console.log("dir=" + readdirSync(d + "/sub").join(","))
+renameSync(d + "/a.txt", d + "/b.txt")
+console.log("renamed=" + String(existsSync(d + "/a.txt")) + "," + String(existsSync(d + "/b.txt")))
+rmSync(d + "/sub", { recursive: true })
+console.log("rm=" + String(existsSync(d + "/sub")))
+console.log("const=" + String(constants.R_OK))
+console.log("done")

package/crates/tish/tests/fs_parity.rs

@@ -0,0 +1,103 @@
+//! Issue #122: Node `fs` parity on the bytecode VM (`tish run` default backend) — the sync
+//! surface via `node:fs` and the async `node:fs/promises` surface (await + rejection).
+
+use std::path::PathBuf;
+use std::process::Command;
+
+fn run_on(backend: &str, fixture: &str, tmp: &str) -> String {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join(fixture);
+    let out = Command::new(&tish)
+        .args([
+            "run",
+            "--backend",
+            backend,
+            "--feature",
+            "fs,process",
+            path.to_str().unwrap(),
+        ])
+        .env("FS_TMP", tmp)
+        .output()
+        .expect("spawn tish run");
+    assert!(
+        out.status.success(),
+        "tish run --backend {backend} {fixture} failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    String::from_utf8_lossy(&out.stdout).into_owned()
+}
+
+fn tmp_dir(tag: &str) -> String {
+    let nanos = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let d = std::env::temp_dir().join(format!("tish_fs_parity_{tag}_{nanos:x}"));
+    std::fs::create_dir_all(&d).unwrap();
+    d.to_str().unwrap().to_string()
+}
+
+const SYNC_EXPECTED: &str = "read=hi!\n\
+     exists=true,false\n\
+     size=3,file=true,dir=false\n\
+     dir=x.txt\n\
+     renamed=false,true\n\
+     rm=false\n\
+     const=4\n\
+     done\n";
+
+const PROMISES_EXPECTED: &str = "read=async hello\n\
+     size=11\n\
+     dir=x\n\
+     access-missing-rejected=true\n\
+     done\n";
+
+#[test]
+fn node_fs_sync_surface_on_every_backend() {
+    for backend in ["vm", "interp"] {
+        let tmp = tmp_dir(&format!("sync_{backend}"));
+        assert_eq!(
+            run_on(backend, "fs_parity_sync.tish", &tmp),
+            SYNC_EXPECTED,
+            "sync surface mismatch on {backend}"
+        );
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+}
+
+#[test]
+fn node_fs_callback_form_on_every_backend() {
+    // Node callback form `readFile(path, (err, data) => …)` on every backend (#122): native's
+    // multi-arg-closure-to-native lowering was fixed upstream, and the interpreter runs the callback
+    // at the eval level (call_func's Native arm) instead of the self-less core bridge.
+    let expected = "write-err-null=true\n\
+         read=callback data\n\
+         size=13,file=true\n\
+         unlink-err-null=true\n\
+         missing-err-set=true,data-null=true\n";
+    for backend in ["vm", "interp", "native"] {
+        let tmp = tmp_dir(&format!("cb_{backend}"));
+        assert_eq!(
+            run_on(backend, "fs_parity_callbacks.tish", &tmp),
+            expected,
+            "callback form mismatch on {backend}"
+        );
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+}
+
+#[test]
+fn node_fs_promises_surface_on_every_backend() {
+    for backend in ["vm", "interp"] {
+        let tmp = tmp_dir(&format!("prom_{backend}"));
+        assert_eq!(
+            run_on(backend, "fs_parity_promises.tish", &tmp),
+            PROMISES_EXPECTED,
+            "promises surface mismatch on {backend}"
+        );
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+}

package/crates/tish/tests/shortcircuit.rs

@@ -9,7 +9,7 @@ use tishlang_vm;
 
 #[test]
 fn test_and_shortcircuit_emits_jump() {
-    let source = "let x = null; let y = x != null && x.foo;";
+    let source = "let x = null; let y = x !== null && x.foo;";
     let program = parse(source).expect("parse");
     let chunk = compile_unoptimized(&program).expect("compile");
     let code = &chunk.code;
@@ -22,7 +22,7 @@ fn test_and_shortcircuit_emits_jump() {
 
 #[test]
 fn test_and_shortcircuit_runs_unoptimized() {
-    let source = "let x = null; let y = x != null && x.foo;";
+    let source = "let x = null; let y = x !== null && x.foo;";
     let program = parse(source).expect("parse");
     let chunk = compile_unoptimized(&program).expect("compile");
     let result = tishlang_vm::run(&chunk);
@@ -35,7 +35,7 @@ fn test_and_shortcircuit_runs_unoptimized() {
 
 #[test]
 fn test_and_shortcircuit_runs_optimized() {
-    let source = "let x = null; let y = x != null && x.foo;";
+    let source = "let x = null; let y = x !== null && x.foo;";
     let program = parse(source).expect("parse");
     let program = tishlang_opt::optimize(&program);
     let chunk = tishlang_bytecode::compile(&program).expect("compile");

package/crates/tish_ast/src/ast.rs

@@ -157,13 +157,15 @@ pub enum ExportDeclaration {
     /// export default expr
     Default(Expr),
     /// Re-export from another module (#305):
-    ///   `export { foo, bar as inc } from "./m"`  -> specifiers, all=false
-    ///   `export * from "./m"`                    -> specifiers=[], all=true
+    ///   `export { foo, bar as inc } from "./m"`  -> specifiers, all=false, from=Some
+    ///   `export * from "./m"`                    -> specifiers=[], all=true, from=Some
+    ///   `export { a, b as c }`                   -> specifiers, all=false, from=None (#415 —
+    ///                                               a LOCAL named export of already-declared bindings)
     /// Specifiers reuse `ImportSpecifier::Named` (`{ a as b }`).
     ReExport {
         specifiers: Vec<ImportSpecifier>,
         all: bool,
-        from: Arc<str>,
+        from: Option<Arc<str>>,
         span: Span,
     },
 }
@@ -173,6 +175,64 @@ pub struct Program {
     pub statements: Vec<Statement>,
 }
 
+/// #469: adopt a Go/Rust/Swift-style `main` entry point.
+///
+/// tish runs top-level statements (JS module semantics), so `fn main() { … }` on its own defines a
+/// function that is never called — a footgun for devs coming from compiled languages (the native
+/// server case: `fn main() { serve(...) }` silently exits). This appends a synthetic `main()`
+/// invocation to the ENTRY program's top-level statements so a defined `main` actually runs: top-level
+/// statements still execute first (module init), then `main`.
+///
+/// Deliberately conservative to avoid a double-invocation: it fires ONLY when a top-level `main`
+/// function is declared AND the program does not already invoke `main()` itself at top level (the
+/// JS-habit `fn main(){…}; main()` shape). This must be applied to the entry module only (not imported
+/// modules) and identically for every backend — call it from `merge_modules` so interp/vm/native/js
+/// stay consistent by construction.
+///
+/// The synthetic call is a plain `main()` (never `await main()`), even for `async fn main`: a blocking
+/// server main never returns anyway, and the interpreter cannot `await` a user async function's result
+/// (a separate pre-existing gap), so an unwrapped call is the one form that behaves identically on
+/// every backend.
+///
+/// Note: this is a tish-specific divergence from JS/node (node does not auto-call `main`); test it via
+/// interp==vm==native cross-checks, and pair any `.tish` fixture with a `.js` that calls `main()`
+/// explicitly so the node reference matches.
+pub fn append_main_entry(statements: &mut Vec<Statement>) {
+    // A top-level `fn main` / `async fn main` declaration.
+    let has_main = statements.iter().any(|s| {
+        matches!(s, Statement::FunDecl { name, .. } if &**name == "main")
+    });
+    if !has_main {
+        return;
+    }
+    // Already invoked at top level? Then the user is driving it — don't double-call.
+    fn is_main_call(expr: &Expr) -> bool {
+        match expr {
+            Expr::Call { callee, .. } => {
+                matches!(callee.as_ref(), Expr::Ident { name, .. } if &**name == "main")
+            }
+            Expr::Await { operand, .. } => is_main_call(operand),
+            _ => false,
+        }
+    }
+    let already_called = statements
+        .iter()
+        .any(|s| matches!(s, Statement::ExprStmt { expr, .. } if is_main_call(expr)));
+    if already_called {
+        return;
+    }
+    let span = Span::default();
+    let call = Expr::Call {
+        callee: Box::new(Expr::Ident {
+            name: Arc::from("main"),
+            span,
+        }),
+        args: Vec::new(),
+        span,
+    };
+    statements.push(Statement::ExprStmt { expr: call, span });
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum Statement {
     Block {
@@ -231,6 +291,16 @@ pub enum Statement {
         body: Box<Statement>,
         span: Span,
     },
+    /// `for (let k in object)` — iterates the object's own enumerable keys (JS `for-in` semantics).
+    /// Distinct from `ForOf` (which iterates values). Kept as a first-class node so every backend
+    /// enumerates keys consistently and `tish fmt` round-trips `for-in`.
+    ForIn {
+        name: Arc<str>,
+        name_span: Span,
+        object: Expr,
+        body: Box<Statement>,
+        span: Span,
+    },
     Return {
         value: Option<Expr>,
         span: Span,
@@ -431,6 +501,9 @@ pub enum Expr {
     },
     /// Arrow function: (params) => body
     ArrowFunction {
+        /// `true` for `async () => …` (#428) — the body runs in async context (`await` allowed) and
+        /// the JS target emits an `async` prefix. Non-async arrows have `async_: false`.
+        async_: bool,
         params: Vec<FunParam>,
         body: ArrowBody,
         span: Span,
@@ -653,6 +726,7 @@ impl Statement {
             | Statement::While { span, .. }
             | Statement::For { span, .. }
             | Statement::ForOf { span, .. }
+            | Statement::ForIn { span, .. }
             | Statement::Return { span, .. }
             | Statement::Break { span, .. }
             | Statement::Continue { span, .. }

package/crates/tish_builtins/Cargo.toml

@@ -11,6 +11,7 @@ repository = { workspace = true }
 ahash = "0.8.11"
 indexmap = "2"
 rand = "0.10.1"
+unicode-normalization = "0.1.25"
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 
 [features]

package/crates/tish_builtins/src/array.rs

@@ -149,11 +149,19 @@ pub fn unshift(arr: &Value, args: &[Value]) -> Value {
     }
 }
 
-pub fn index_of(arr: &Value, search: &Value) -> Value {
+pub fn index_of(arr: &Value, search: &Value, from: Option<&Value>) -> Value {
     let arr = as_boxed_array(arr); let arr = &*arr;
     if let Value::Array(arr) = arr {
         let arr_borrow = arr.borrow();
-        for (i, v) in arr_borrow.iter().enumerate() {
+        // `fromIndex`: clamp positive to [0, len]; negative counts from the end (`len + n`, floored
+        // at 0). Same handling as `includes`. Absent → 0.
+        let len = arr_borrow.len() as i64;
+        let start = match from {
+            Some(Value::Number(n)) if *n >= 0.0 => (*n as i64).min(len).max(0) as usize,
+            Some(Value::Number(n)) if *n < 0.0 => ((len + *n as i64).max(0)) as usize,
+            _ => 0,
+        };
+        for (i, v) in arr_borrow.iter().enumerate().skip(start) {
             if v.strict_eq(search) {
                 return Value::Number(i as f64);
             }
@@ -218,6 +226,57 @@ pub fn reverse(arr: &Value) -> Value {
     }
 }
 
+/// `Array.prototype.toReversed()` — a reversed COPY (ES2023); the receiver is untouched.
+pub fn to_reversed(arr: &Value) -> Value {
+    let mut v = snapshot_values(arr);
+    v.reverse();
+    Value::Array(VmRef::new(v))
+}
+
+/// `Array.prototype.toSorted(cmp?)` — a sorted COPY (ES2023); the receiver is untouched. Sorting runs
+/// on the copy via the same comparator/default machinery as `sort`.
+pub fn to_sorted(arr: &Value, comparator: Option<&Value>) -> Value {
+    let copy = Value::Array(VmRef::new(snapshot_values(arr)));
+    match comparator {
+        Some(cmp @ Value::Function(_)) => sort_with_comparator(&copy, cmp),
+        _ => sort_default(&copy),
+    }
+}
+
+/// `Array.prototype.with(index, value)` — a COPY with `index` replaced (ES2023). A negative index
+/// counts from the end; an out-of-range index parks a catchable `RangeError` (matches node's message).
+pub fn with(arr: &Value, index: &Value, value: &Value) -> Value {
+    let mut v = snapshot_values(arr);
+    let len = v.len() as i64;
+    let rel = match index {
+        Value::Number(n) if n.is_finite() => *n as i64,
+        _ => 0,
+    };
+    let actual = if rel >= 0 { rel } else { len + rel };
+    if actual < 0 || actual >= len {
+        tishlang_core::set_pending_throw(tishlang_core::range_error(format!(
+            "Invalid index : {}",
+            rel
+        )));
+        return Value::Null;
+    }
+    v[actual as usize] = value.clone();
+    Value::Array(VmRef::new(v))
+}
+
+/// `Array.prototype.toSpliced(start, deleteCount?, ...items)` — a COPY with the splice applied (ES2023);
+/// unlike `splice` (which returns the removed elements) this returns the resulting array.
+pub fn to_spliced(
+    arr: &Value,
+    start: &Value,
+    delete_count: Option<&Value>,
+    items: &[Value],
+) -> Value {
+    let copy = Value::Array(VmRef::new(snapshot_values(arr)));
+    splice(&copy, start, delete_count, items);
+    copy
+}
+
 /// Fisher-Yates shuffle. Returns a new shuffled array (does not mutate).
 pub fn shuffle(arr: &Value) -> Value {
     let arr = as_boxed_array(arr); let arr = &*arr;
@@ -273,6 +332,55 @@ pub fn fill(arr: &Value, value: &Value, start: &Value, end: &Value) -> Value {
     }
 }
 
+pub fn last_index_of(arr: &Value, search: &Value, from: Option<&Value>) -> Value {
+    let arr = as_boxed_array(arr);
+    let arr = &*arr;
+    if let Value::Array(arr) = arr {
+        let arr_borrow = arr.borrow();
+        let len = arr_borrow.len() as i64;
+        // Default fromIndex is len-1; positive clamps to len-1; negative counts back from the end.
+        let start = match from {
+            Some(Value::Number(n)) if *n >= 0.0 => (*n as i64).min(len - 1),
+            Some(Value::Number(n)) => len + *n as i64,
+            _ => len - 1,
+        };
+        let mut i = start;
+        while i >= 0 {
+            if let Some(v) = arr_borrow.get(i as usize) {
+                if v.strict_eq(search) {
+                    return Value::Number(i as f64);
+                }
+            }
+            i -= 1;
+        }
+    }
+    Value::Number(-1.0)
+}
+
+/// `copyWithin(target, start, end)` — copy the `[start, end)` block to `target`, in place; returns
+/// the array. Indices are clamped, negatives count from the end.
+pub fn copy_within(arr: &Value, target: &Value, start: &Value, end: &Value) -> Value {
+    let arr = as_boxed_array(arr);
+    let arr = &*arr;
+    if let Value::Array(a) = arr {
+        let mut v = a.borrow_mut();
+        let len = v.len();
+        let t = normalize_index(target, len as i64, 0);
+        let s = normalize_index(start, len as i64, 0);
+        let e = normalize_index(end, len as i64, len);
+        if s < e && t < len {
+            let count = (e - s).min(len - t);
+            let block: Vec<Value> = v[s..s + count].to_vec();
+            for (k, val) in block.into_iter().enumerate() {
+                v[t + k] = val;
+            }
+        }
+        drop(v);
+        return Value::Array(a.clone());
+    }
+    Value::Null
+}
+
 pub fn slice(arr: &Value, start: &Value, end: &Value) -> Value {
     let arr = as_boxed_array(arr); let arr = &*arr;
     if let Value::Array(arr) = arr {
@@ -417,16 +525,25 @@ pub fn filter(arr: &Value, callback: &Value) -> Value {
     }
 }
 
-pub fn reduce(arr: &Value, callback: &Value, initial: &Value) -> Value {
+/// `initial` is `None` when no initial value was passed (`arr.reduce(fn)`) and `Some` for an explicit
+/// one (`arr.reduce(fn, x)`, INCLUDING `arr.reduce(fn, null)`). This distinction matters: reducing an
+/// empty array with NO initial value is a `TypeError` in JS, while an explicit initial (even `null`)
+/// is returned as-is. A `Value::Null` sentinel can't tell the two apart — hence `Option`.
+pub fn reduce(arr: &Value, callback: &Value, initial: Option<&Value>) -> Value {
     // Packed fast path: fold the `Vec<f64>` snapshot directly. Same no-initial rule as the boxed
     // path (absent init → first element as the seed, scan from index 1).
     if let Some((data, cb)) = packed_snapshot(arr, callback) {
         // `reduce` passes `(accumulator, element, index, array)` — the array is the 4th arg.
         let arr_value = arr.clone();
-        let (start_idx, mut acc) = if matches!(initial, Value::Null) && !data.is_empty() {
-            (1usize, Value::Number(data[0]))
-        } else {
-            (0usize, initial.clone())
+        let (start_idx, mut acc) = match initial {
+            Some(v) => (0usize, v.clone()),
+            None if !data.is_empty() => (1usize, Value::Number(data[0])),
+            None => {
+                tishlang_core::set_pending_throw(tishlang_core::type_error(
+                    "Reduce of empty array with no initial value",
+                ));
+                return Value::Null;
+            }
         };
         // `skip(start_idx)` preserves the true element index for the callback's 3rd arg.
         for (i, &x) in data.iter().enumerate().skip(start_idx) {
@@ -440,11 +557,15 @@ pub fn reduce(arr: &Value, callback: &Value, initial: &Value) -> Value {
         let arr_borrow = arr.borrow().clone(); // #382: snapshot; drop the guard before any callback
         let arr_value = Value::Array(arr.clone()); // 4th callback arg (JS `array`)
         let len = arr_borrow.len();
-        let (start_idx, mut acc) = if matches!(initial, Value::Null) && !arr_borrow.is_empty() {
-            // No initial value: use first element as acc, start from index 1
-            (1, arr_borrow[0].clone())
-        } else {
-            (0, initial.clone())
+        let (start_idx, mut acc) = match initial {
+            Some(v) => (0, v.clone()),
+            None if !arr_borrow.is_empty() => (1, arr_borrow[0].clone()),
+            None => {
+                tishlang_core::set_pending_throw(tishlang_core::type_error(
+                    "Reduce of empty array with no initial value",
+                ));
+                return Value::Null;
+            }
         };
         for i in start_idx..len {
             if tishlang_core::has_pending_throw() { return acc; } // #303
@@ -457,6 +578,64 @@ pub fn reduce(arr: &Value, callback: &Value, initial: &Value) -> Value {
     }
 }
 
+/// `reduceRight(cb, initial?)` — like [`reduce`] but folds right-to-left. `initial` is `None` when
+/// omitted (empty array + no initial → catchable TypeError).
+pub fn reduce_right(arr: &Value, callback: &Value, initial: Option<&Value>) -> Value {
+    let data = snapshot_values(arr);
+    if let Value::Function(cb) = callback {
+        let arr_value = arr.clone();
+        let len = data.len();
+        let (start, mut acc) = match initial {
+            Some(v) => (len, v.clone()),
+            None if len > 0 => (len - 1, data[len - 1].clone()),
+            None => {
+                tishlang_core::set_pending_throw(tishlang_core::type_error(
+                    "Reduce of empty array with no initial value",
+                ));
+                return Value::Null;
+            }
+        };
+        let mut i = start;
+        while i > 0 {
+            i -= 1;
+            if tishlang_core::has_pending_throw() {
+                return acc;
+            }
+            acc = cb.call(&[
+                acc,
+                data[i].clone(),
+                Value::Number(i as f64),
+                arr_value.clone(),
+            ]);
+        }
+        acc
+    } else {
+        Value::Null
+    }
+}
+
+/// `arr.keys()` — an iterator over the indices `0..len`.
+pub fn keys(arr: &Value) -> Value {
+    let len = snapshot_values(arr).len();
+    crate::iterator::array_iterator((0..len).map(|i| Value::Number(i as f64)).collect())
+}
+
+/// `arr.values()` — an iterator over the elements.
+pub fn values(arr: &Value) -> Value {
+    crate::iterator::array_iterator(snapshot_values(arr))
+}
+
+/// `arr.entries()` — an iterator over `[index, element]` pairs.
+pub fn entries(arr: &Value) -> Value {
+    crate::iterator::array_iterator(
+        snapshot_values(arr)
+            .into_iter()
+            .enumerate()
+            .map(|(i, v)| Value::Array(VmRef::new(vec![Value::Number(i as f64), v])))
+            .collect(),
+    )
+}
+
 pub fn for_each(arr: &Value, callback: &Value) -> Value {
     if let Some((data, cb)) = packed_snapshot(arr, callback) {
         let arr_value = arr.clone(); // 3rd callback arg (JS `array`)
@@ -974,14 +1153,14 @@ mod packed_hof_tests {
         let n = na(&[3.0, 1.0, 4.0, 1.0, 5.0]);
         let add = cb_num(|acc, x| acc + x);
         // With init.
-        assert_eq!(reduce(&n, &add, &Value::Number(0.0)).as_number(), Some(14.0));
-        // No init → first element seeds, scan from index 1 (same total here).
-        assert_eq!(reduce(&n, &add, &Value::Null).as_number(), Some(14.0));
+        assert_eq!(reduce(&n, &add, Some(&Value::Number(0.0))).as_number(), Some(14.0));
+        // No init (None) → first element seeds, scan from index 1 (same total here).
+        assert_eq!(reduce(&n, &add, None).as_number(), Some(14.0));
         // Index arg: callback (acc, _elem, index) — sum the indices 0..5 = 10.
         let sum_idx = Value::native(|a: &[Value]| {
             Value::Number(a[0].as_number().unwrap() + a[2].as_number().unwrap())
         });
-        assert_eq!(reduce(&n, &sum_idx, &Value::Number(0.0)).as_number(), Some(10.0));
+        assert_eq!(reduce(&n, &sum_idx, Some(&Value::Number(0.0))).as_number(), Some(10.0));
     }
 
     #[test]