@tishlang/tish-format 2.12.0 → 2.35.0

package/crates/tish_resolve/src/lib.rs

@@ -177,6 +177,13 @@ fn collect_stmt(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            object: iterable,
+            body,
+            ..
         } => {
             consider(source, lsp_line, lsp_char, name_span, name.clone(), best);
             collect_expr(iterable, source, lsp_line, lsp_char, best);
@@ -286,6 +293,7 @@ fn collect_stmt(
                 collect_stmt(inner, source, lsp_line, lsp_char, best)
             }
             ExportDeclaration::Default(e) => collect_expr(e, source, lsp_line, lsp_char, best),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::TypeAlias {
             name, name_span, ..
@@ -938,7 +946,12 @@ fn member_chain_collect_stmt(
             }
             member_chain_collect_stmt(body, source, lsp_line, lsp_char, best);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             member_chain_collect_expr(iterable, source, lsp_line, lsp_char, best);
             member_chain_collect_stmt(body, source, lsp_line, lsp_char, best);
         }
@@ -1009,6 +1022,7 @@ fn member_chain_collect_stmt(
             ExportDeclaration::Default(e) => {
                 member_chain_collect_expr(e, source, lsp_line, lsp_char, best)
             }
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::Import { .. }
         | Statement::Break { .. }
@@ -1412,6 +1426,13 @@ fn walk_stmt_resolve(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            object: iterable,
+            body,
+            ..
         } => {
             if *name_span == tgt_span && name.as_ref() == target.name.as_ref() {
                 return Some(*name_span);
@@ -1598,6 +1619,7 @@ fn walk_stmt_resolve(
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => walk_stmt_resolve(inner, scopes, target),
             ExportDeclaration::Default(e) => walk_expr_resolve(e, scopes, target),
+            ExportDeclaration::ReExport { .. } => None,
         },
         Statement::TypeAlias {
             name, name_span, ..
@@ -2025,6 +2047,13 @@ fn check_unresolved_stmt(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            object: iterable,
+            body,
+            ..
         } => {
             check_unresolved_expr(iterable, scopes, out);
             scopes.push();
@@ -2156,6 +2185,7 @@ fn check_unresolved_stmt(
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => check_unresolved_stmt(inner, scopes, out),
             ExportDeclaration::Default(e) => check_unresolved_expr(e, scopes, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::TypeAlias {
             name, name_span, ..
@@ -2489,6 +2519,7 @@ fn enumerate_stmt(stmt: &Statement, exported: bool, out: &mut Vec<BindingSite>)
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => enumerate_stmt(inner, true, out),
             ExportDeclaration::Default(e) => enumerate_expr(e, exported, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::VarDecl {
             name,
@@ -2551,6 +2582,13 @@ fn enumerate_stmt(stmt: &Statement, exported: bool, out: &mut Vec<BindingSite>)
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            object: iterable,
+            body,
+            ..
         } => {
             out.push(BindingSite {
                 name: name.clone(),
@@ -2726,7 +2764,12 @@ fn jsx_tags_stmt(s: &Statement, out: &mut std::collections::HashSet<Arc<str>>) {
             }
             jsx_tags_stmt(body, out);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             jsx_tags_expr(iterable, out);
             jsx_tags_stmt(body, out);
         }
@@ -2788,6 +2831,7 @@ fn jsx_tags_stmt(s: &Statement, out: &mut std::collections::HashSet<Arc<str>>) {
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => jsx_tags_stmt(inner, out),
             ExportDeclaration::Default(e) => jsx_tags_expr(e, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::Import { .. }
         | Statement::Break { .. }
@@ -3051,6 +3095,13 @@ fn collect_block_locals(
             body,
             span,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            body,
+            span,
+            ..
         } => {
             if pos::span_contains_lsp_position(source, span, lsp_line, lsp_char)
                 && pos::span_contains_lsp_position(
@@ -3422,6 +3473,12 @@ fn walk_stmt_completion(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            object: iterable,
+            body,
+            ..
         } => {
             walk_expr_completion(iterable, source, lsp_line, lsp_char, stack, best);
             let body_sp = body.as_ref().span();
@@ -3532,6 +3589,7 @@ fn walk_stmt_completion(
             ExportDeclaration::Default(e) => {
                 walk_expr_completion(e, source, lsp_line, lsp_char, stack, best);
             }
+            ExportDeclaration::ReExport { .. } => {}
         },
     }
 }
@@ -3893,7 +3951,12 @@ fn tref_stmt(stmt: &Statement, out: &mut Vec<TypeOcc>) {
             }
             tref_stmt(body, out);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             tref_expr(iterable, out);
             tref_stmt(body, out);
         }
@@ -3945,6 +4008,7 @@ fn tref_stmt(stmt: &Statement, out: &mut Vec<TypeOcc>) {
         Statement::Export { declaration, .. } => match declaration.as_ref() {
             ExportDeclaration::Named(inner) => tref_stmt(inner, out),
             ExportDeclaration::Default(e) => tref_expr(e, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         _ => {}
     }
@@ -4053,7 +4117,12 @@ fn refs_stmt(
             }
             refs_stmt(body, program, source, name, def_span, out);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             refs_expr(iterable, program, source, name, def_span, out);
             refs_stmt(body, program, source, name, def_span, out);
         }
@@ -4132,6 +4201,7 @@ fn refs_stmt(
                 refs_stmt(inner, program, source, name, def_span, out)
             }
             ExportDeclaration::Default(e) => refs_expr(e, program, source, name, def_span, out),
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::Import { .. }
         | Statement::Break { .. }
@@ -4648,7 +4718,7 @@ mod tests {
 
     #[test]
     fn mutual_recursion_not_unresolved_or_unused() {
-        let src = "fn even(n) { if (n == 0) { return true } return odd(n - 1) }\nfn odd(n) { if (n == 0) { return false } return even(n - 1) }\neven(10)\n";
+        let src = "fn even(n) { if (n === 0) { return true } return odd(n - 1) }\nfn odd(n) { if (n === 0) { return false } return even(n - 1) }\neven(10)\n";
         let program = parse(src).expect("parse");
         assert!(
             collect_unresolved_identifiers(&program).is_empty(),

package/crates/tish_runtime/Cargo.toml

@@ -52,7 +52,9 @@ http-hyper = [
     "tokio/rt",
     "tokio/io-util",
 ]
-fs = []
+# `fs/promises` returns settled promises, so fs pulls in the promise machinery.
+# `mkdtemp` needs a random suffix (predictable/timestamp names are a temp-dir security smell).
+fs = ["promise", "dep:rand"]
 process = []
 # Interactive terminal I/O (issue #101): raw mode, key/resize events, size, alt screen.
 tty = ["dep:crossterm"]
@@ -81,6 +83,8 @@ reqwest = { version = "0.13.2", default-features = false, features = ["rustls",
 futures = { version = "0.3.32", optional = true }
 bytes = { version = "1", optional = true }
 tiny_http = { version = "0.12.0", optional = true }
+# fs feature only: random suffix for `mkdtemp`.
+rand = { version = "0.10.1", optional = true }
 socket2 = { version = "0.5", features = ["all"], optional = true }
 libc = { version = "0.2", optional = true }
 arc-swap = { version = "1", optional = true }
@@ -94,3 +98,8 @@ core_affinity = { version = "0.8", optional = true }
 tokio-tungstenite = { version = "0.29", optional = true }
 futures-util = { version = "0.3", optional = true }
 lazy_static = { version = "1", optional = true }
+
+# #381 native-codegen recursion guard: stack-pressure probe for guarded self-recursive fns.
+# Non-wasm only — wasm traps on overflow inside its own sandbox, so the guard is a no-op there.
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+stacker = "0.1"

package/crates/tish_runtime/src/fs_ext.rs

@@ -0,0 +1,359 @@
+//! Node-compatible `fs` surface for `tish:fs` and the async `tish:fs/promises` module
+//! (issue #122). Each operation has a single `*_core` returning `Result<Value, Value>`
+//! (Ok = result, Err = an error value); a macro derives the synchronous export (returns the
+//! value, or the error object on failure — tish's sync convention) and the promise export
+//! (a fulfilled/rejected Promise — Node's `fs/promises` convention).
+//!
+//! Node names are primary (`readFileSync`, `statSync`, …); the existing tish names
+//! (`readFile`, `readDir`, `fileExists`, `isDir`) are kept as aliases in the backends.
+#![cfg(feature = "fs")]
+
+use crate::promise::{promise_reject, promise_resolve};
+use std::time::{SystemTime, UNIX_EPOCH};
+use tishlang_builtins::helpers::make_error_value;
+use tishlang_core::{ObjectMap, Value, VmRef};
+
+fn path_arg(args: &[Value], i: usize) -> String {
+    args.get(i).map(|v| v.to_display_string()).unwrap_or_default()
+}
+
+/// Map an io::Error to the same error value `read_file` already produces.
+fn io_err(e: std::io::Error) -> Value {
+    make_error_value(e)
+}
+
+fn unwrap(r: Result<Value, Value>) -> Value {
+    match r {
+        Ok(v) => v,
+        Err(e) => e,
+    }
+}
+
+fn settle(r: Result<Value, Value>) -> Value {
+    match r {
+        Ok(v) => promise_resolve(&[v]),
+        Err(e) => promise_reject(&[e]),
+    }
+}
+
+/// Node callback form: the trailing arg is `(err, result) => …`. Run the op on the remaining
+/// args, invoke the callback with `(null, value)` on success or `(err, null)` on failure, and
+/// return null. The op is synchronous under the hood, so the callback fires synchronously.
+fn run_callback(core: fn(&[Value]) -> Result<Value, Value>, args: &[Value]) -> Value {
+    let cb = args.last().cloned().unwrap_or(Value::Null);
+    let op_args: &[Value] = if args.len() > 1 { &args[..args.len() - 1] } else { &[] };
+    let (err, data) = match core(op_args) {
+        Ok(v) => (Value::Null, v),
+        Err(e) => (e, Value::Null),
+    };
+    tishlang_core::value_call(&cb, &[err, data]);
+    Value::Null
+}
+
+/// Generate the sync export (dual: a trailing function arg switches to the Node callback form)
+/// and the promise export over a `*_core`.
+macro_rules! fs_method {
+    ($sync:ident, $promise:ident, $core:ident) => {
+        pub fn $sync(args: &[Value]) -> Value {
+            if let Some(Value::Function(_)) = args.last() {
+                return run_callback($core, args);
+            }
+            unwrap($core(args))
+        }
+        pub fn $promise(args: &[Value]) -> Value {
+            settle($core(args))
+        }
+    };
+}
+
+fn ms_since_epoch(t: std::io::Result<SystemTime>) -> f64 {
+    t.ok()
+        .and_then(|st| st.duration_since(UNIX_EPOCH).ok())
+        .map(|d| d.as_secs_f64() * 1000.0)
+        .unwrap_or(0.0)
+}
+
+/// Build a Node-like `Stats` object from metadata (predicate methods + size + times + mode).
+fn stats_object(md: &std::fs::Metadata) -> Value {
+    let mut m = ObjectMap::default();
+    let is_file = md.is_file();
+    let is_dir = md.is_dir();
+    let is_symlink = md.file_type().is_symlink();
+    m.insert("isFile".into(), Value::native(move |_| Value::Bool(is_file)));
+    m.insert("isDirectory".into(), Value::native(move |_| Value::Bool(is_dir)));
+    m.insert("isSymbolicLink".into(), Value::native(move |_| Value::Bool(is_symlink)));
+    m.insert("isBlockDevice".into(), Value::native(|_| Value::Bool(false)));
+    m.insert("isCharacterDevice".into(), Value::native(|_| Value::Bool(false)));
+    m.insert("isFIFO".into(), Value::native(|_| Value::Bool(false)));
+    m.insert("isSocket".into(), Value::native(|_| Value::Bool(false)));
+    m.insert("size".into(), Value::Number(md.len() as f64));
+    m.insert("mtimeMs".into(), Value::Number(ms_since_epoch(md.modified())));
+    m.insert("atimeMs".into(), Value::Number(ms_since_epoch(md.accessed())));
+    m.insert("birthtimeMs".into(), Value::Number(ms_since_epoch(md.created())));
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt;
+        m.insert("mode".into(), Value::Number(md.mode() as f64));
+        m.insert("uid".into(), Value::Number(md.uid() as f64));
+        m.insert("gid".into(), Value::Number(md.gid() as f64));
+        m.insert("ino".into(), Value::Number(md.ino() as f64));
+    }
+    Value::object(m)
+}
+
+// ── cores ─────────────────────────────────────────────────────────────────────────────────
+
+pub fn read_file_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::read_to_string(path_arg(args, 0))
+        .map(|s| Value::String(s.into()))
+        .map_err(io_err)
+}
+
+pub fn read_file_bytes_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::read(path_arg(args, 0))
+        .map(|b| Value::Array(VmRef::new(b.into_iter().map(|x| Value::Number(x as f64)).collect())))
+        .map_err(io_err)
+}
+
+/// Write a string, or a byte array (numbers 0–255), to a file.
+pub fn write_file_core(args: &[Value]) -> Result<Value, Value> {
+    let path = path_arg(args, 0);
+    let res = match args.get(1) {
+        Some(Value::Array(a)) => {
+            let bytes: Vec<u8> = a
+                .borrow()
+                .iter()
+                .map(|v| if let Value::Number(n) = v { *n as u8 } else { 0 })
+                .collect();
+            std::fs::write(&path, bytes)
+        }
+        Some(v) => std::fs::write(&path, v.to_display_string()),
+        None => std::fs::write(&path, ""),
+    };
+    res.map(|_| Value::Null).map_err(io_err)
+}
+
+pub fn append_file_core(args: &[Value]) -> Result<Value, Value> {
+    use std::io::Write;
+    let path = path_arg(args, 0);
+    let data = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
+    std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .and_then(|mut f| f.write_all(data.as_bytes()))
+        .map(|_| Value::Null)
+        .map_err(io_err)
+}
+
+pub fn stat_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::metadata(path_arg(args, 0)).map(|m| stats_object(&m)).map_err(io_err)
+}
+pub fn lstat_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::symlink_metadata(path_arg(args, 0)).map(|m| stats_object(&m)).map_err(io_err)
+}
+
+pub fn readdir_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::read_dir(path_arg(args, 0))
+        .map(|entries| {
+            let names: Vec<Value> = entries
+                .filter_map(|e| e.ok())
+                .map(|e| Value::String(e.file_name().to_string_lossy().into()))
+                .collect();
+            Value::Array(VmRef::new(names))
+        })
+        .map_err(io_err)
+}
+
+/// `mkdir(path[, { recursive }])` — recursive creates parents.
+pub fn mkdir_core(args: &[Value]) -> Result<Value, Value> {
+    let path = path_arg(args, 0);
+    let recursive = opt_bool(args.get(1), "recursive");
+    let res = if recursive {
+        std::fs::create_dir_all(&path)
+    } else {
+        std::fs::create_dir(&path)
+    };
+    res.map(|_| Value::Null).map_err(io_err)
+}
+
+/// `rm(path[, { recursive }])` — file, or whole tree when recursive.
+pub fn rm_core(args: &[Value]) -> Result<Value, Value> {
+    let path = path_arg(args, 0);
+    let recursive = opt_bool(args.get(1), "recursive");
+    let md = std::fs::symlink_metadata(&path);
+    let res = match md {
+        Ok(m) if m.is_dir() => {
+            if recursive {
+                std::fs::remove_dir_all(&path)
+            } else {
+                std::fs::remove_dir(&path)
+            }
+        }
+        _ => std::fs::remove_file(&path),
+    };
+    res.map(|_| Value::Null).map_err(io_err)
+}
+
+pub fn rmdir_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::remove_dir(path_arg(args, 0)).map(|_| Value::Null).map_err(io_err)
+}
+pub fn unlink_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::remove_file(path_arg(args, 0)).map(|_| Value::Null).map_err(io_err)
+}
+pub fn rename_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::rename(path_arg(args, 0), path_arg(args, 1)).map(|_| Value::Null).map_err(io_err)
+}
+pub fn copy_file_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::copy(path_arg(args, 0), path_arg(args, 1)).map(|_| Value::Null).map_err(io_err)
+}
+pub fn realpath_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::canonicalize(path_arg(args, 0))
+        .map(|p| Value::String(p.to_string_lossy().into()))
+        .map_err(io_err)
+}
+pub fn readlink_core(args: &[Value]) -> Result<Value, Value> {
+    std::fs::read_link(path_arg(args, 0))
+        .map(|p| Value::String(p.to_string_lossy().into()))
+        .map_err(io_err)
+}
+pub fn truncate_core(args: &[Value]) -> Result<Value, Value> {
+    let len = match args.get(1) {
+        Some(Value::Number(n)) => *n as u64,
+        _ => 0,
+    };
+    std::fs::OpenOptions::new()
+        .write(true)
+        .open(path_arg(args, 0))
+        .and_then(|f| f.set_len(len))
+        .map(|_| Value::Null)
+        .map_err(io_err)
+}
+
+/// `mkdtemp(prefix)` — create a uniquely-named temp dir and return its path. Node appends 6 RANDOM
+/// characters; a timestamp suffix is both predictable (a temp-dir security smell) and collision-prone
+/// under rapid calls. Use a random suffix and rely on `create_dir`'s exclusive semantics, retrying on
+/// the astronomically-rare collision.
+pub fn mkdtemp_core(args: &[Value]) -> Result<Value, Value> {
+    let prefix = path_arg(args, 0);
+    for _ in 0..16 {
+        // 10 base-36 chars derived from a random u64 (~51 bits of entropy).
+        let mut n: u64 = rand::random();
+        let mut suffix = String::with_capacity(10);
+        for _ in 0..10 {
+            suffix.push(char::from_digit((n % 36) as u32, 36).unwrap());
+            n /= 36;
+        }
+        let path = format!("{}{}", prefix, suffix);
+        match std::fs::create_dir(&path) {
+            Ok(()) => return Ok(Value::String(path.into())),
+            Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
+            Err(e) => return Err(io_err(e)),
+        }
+    }
+    Err(io_err(std::io::Error::new(
+        std::io::ErrorKind::AlreadyExists,
+        "mkdtemp: could not create a unique temporary directory",
+    )))
+}
+
+/// `cp(src, dest[, { recursive }])` — copy a file, or a directory tree when recursive.
+pub fn cp_core(args: &[Value]) -> Result<Value, Value> {
+    let src = path_arg(args, 0);
+    let dest = path_arg(args, 1);
+    let recursive = opt_bool(args.get(2), "recursive");
+    copy_recursive(std::path::Path::new(&src), std::path::Path::new(&dest), recursive)
+        .map(|_| Value::Null)
+        .map_err(io_err)
+}
+
+fn copy_recursive(src: &std::path::Path, dest: &std::path::Path, recursive: bool) -> std::io::Result<()> {
+    if src.is_dir() {
+        if !recursive {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "cp on a directory requires { recursive: true }",
+            ));
+        }
+        std::fs::create_dir_all(dest)?;
+        for entry in std::fs::read_dir(src)? {
+            let entry = entry?;
+            copy_recursive(&entry.path(), &dest.join(entry.file_name()), true)?;
+        }
+        Ok(())
+    } else {
+        if let Some(parent) = dest.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        std::fs::copy(src, dest).map(|_| ())
+    }
+}
+
+fn opt_bool(v: Option<&Value>, key: &str) -> bool {
+    match v {
+        Some(Value::Object(o)) => o
+            .borrow()
+            .strings
+            .get(key)
+            .map(|b| b.is_truthy())
+            .unwrap_or(false),
+        _ => false,
+    }
+}
+
+// ── sync + promise exports ──────────────────────────────────────────────────────────────────
+
+fs_method!(read_file, read_file_promise, read_file_core);
+fs_method!(read_file_bytes, read_file_bytes_promise, read_file_bytes_core);
+fs_method!(write_file, write_file_promise, write_file_core);
+fs_method!(append_file, append_file_promise, append_file_core);
+fs_method!(stat, stat_promise, stat_core);
+fs_method!(lstat, lstat_promise, lstat_core);
+fs_method!(readdir, readdir_promise, readdir_core);
+fs_method!(mkdir, mkdir_promise, mkdir_core);
+fs_method!(rm, rm_promise, rm_core);
+fs_method!(rmdir, rmdir_promise, rmdir_core);
+fs_method!(unlink, unlink_promise, unlink_core);
+fs_method!(rename, rename_promise, rename_core);
+fs_method!(copy_file, copy_file_promise, copy_file_core);
+fs_method!(realpath, realpath_promise, realpath_core);
+fs_method!(readlink, readlink_promise, readlink_core);
+fs_method!(truncate, truncate_promise, truncate_core);
+fs_method!(mkdtemp, mkdtemp_promise, mkdtemp_core);
+fs_method!(cp, cp_promise, cp_core);
+
+// `exists` / `access` never error — they answer a boolean.
+pub fn exists(args: &[Value]) -> Value {
+    Value::Bool(std::path::Path::new(&path_arg(args, 0)).exists())
+}
+pub fn exists_promise(args: &[Value]) -> Value {
+    promise_resolve(&[exists(args)])
+}
+/// `accessSync(path)` → true if the path exists (tish-friendly); the promise form resolves
+/// `true` / rejects with an error, matching `fs/promises.access`.
+pub fn access(args: &[Value]) -> Value {
+    exists(args)
+}
+pub fn access_promise(args: &[Value]) -> Value {
+    let path = path_arg(args, 0);
+    if std::path::Path::new(&path).exists() {
+        promise_resolve(&[Value::Null])
+    } else {
+        promise_reject(&[Value::String(format!("ENOENT: no such file '{}'", path).into())])
+    }
+}
+
+/// `isDir(path)` — tish convenience kept for back-compat (≈ `statSync().isDirectory()`).
+pub fn is_dir(args: &[Value]) -> Value {
+    Value::Bool(std::path::Path::new(&path_arg(args, 0)).is_dir())
+}
+
+/// `fs.constants` — the access-mode flags.
+pub fn constants() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert("F_OK".into(), Value::Number(0.0));
+    m.insert("R_OK".into(), Value::Number(4.0));
+    m.insert("W_OK".into(), Value::Number(2.0));
+    m.insert("X_OK".into(), Value::Number(1.0));
+    Value::object(m)
+}

package/crates/tish_runtime/src/http.rs

@@ -1110,16 +1110,30 @@ where
     drop(tx);
 
     let mut count = 0usize;
-    while let Ok((req_prim, resp_tx)) = rx.recv() {
-        let req_value = req_prim.into_value();
-        let response_value = handler.call(&[req_value]);
-        let resp_prim = ResponsePrimitive::from_value(&response_value);
-        let _ = resp_tx.send(resp_prim);
-
-        count += 1;
-        if max_requests.map(|m| count >= m).unwrap_or(false) {
-            stop.store(true, Ordering::Relaxed);
-            break;
+    // #384: `recv_timeout` (not a blocking `recv`) so a handler's scheduled timers still fire when the
+    // server is idle. Handler calls all run on this single VM thread, so the timer registry is here.
+    loop {
+        match rx.recv_timeout(Duration::from_millis(250)) {
+            Ok((req_prim, resp_tx)) => {
+                let req_value = req_prim.into_value();
+                let response_value = handler.call(&[req_value]);
+                crate::timers::drain_timers();
+                let resp_prim = ResponsePrimitive::from_value(&response_value);
+                let _ = resp_tx.send(resp_prim);
+
+                count += 1;
+                if max_requests.map(|m| count >= m).unwrap_or(false) {
+                    stop.store(true, Ordering::Relaxed);
+                    break;
+                }
+            }
+            Err(mpsc::RecvTimeoutError::Timeout) => {
+                crate::timers::drain_timers();
+                if stop.load(Ordering::Relaxed) {
+                    break;
+                }
+            }
+            Err(mpsc::RecvTimeoutError::Disconnected) => break,
         }
     }
 
@@ -1181,6 +1195,10 @@ fn worker_loop_direct(
             Ok(None) => {} // timeout; re-check stop flag
             Err(_) => break,
         }
+        // #384: fire any timers a handler scheduled. The handler runs on this accept thread, so its
+        // `setTimeout`/`setInterval` callbacks live in this thread's registry; the ≤250ms `recv_timeout`
+        // above means they fire within that window even when no new requests arrive.
+        crate::timers::drain_timers();
     }
 }