@tishlang/tish 2.12.0 → 2.16.13

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -98,6 +98,21 @@ fn resolve_import_to_key(
     ))
 }
 
+/// The module specifier a statement imports/re-exports from, if any — covers both
+/// `import … from "x"` and `export … from "x"` (#305 re-export). Dependency discovery and cycle
+/// detection use this so they follow re-export edges, not just plain imports (otherwise a module
+/// reached only via a re-export would never be loaded).
+fn stmt_module_source(stmt: &Statement) -> Option<&str> {
+    match stmt {
+        Statement::Import { from, .. } => Some(&**from),
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            ExportDeclaration::ReExport { from, .. } => Some(&**from),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
 /// Resolve all modules starting from the entry file. Returns modules in dependency order.
 pub fn resolve_virtual(
     entry_path: &str,
@@ -163,7 +178,7 @@ fn load_module_recursive(
 
     let from_dir = parent_dir(module_path);
     for stmt in &program.statements {
-        if let Statement::Import { from, .. } = stmt {
+        if let Some(from) = stmt_module_source(stmt) {
             if is_native_import(from) {
                 continue;
             }
@@ -217,7 +232,7 @@ fn has_cycle_from(
     visiting: &mut HashSet<usize>,
 ) -> Result<bool, String> {
     for stmt in &program.statements {
-        if let Statement::Import { from, .. } = stmt {
+        if let Some(from) = stmt_module_source(stmt) {
             if is_native_import(from) {
                 continue;
             }
@@ -292,6 +307,40 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                         let default_name = format!("__default_{}", idx);
                         module_exports[idx].insert("default".to_string(), default_name);
                     }
+                    // #305: re-export — map each re-exported name to the DEP's binding (the dep is
+                    // earlier in load order, so its export table is already built). `export *` copies
+                    // every dep export without overriding an explicit one; `export { a as b }` maps
+                    // b -> dep's binding for a. Mirrors `merge_modules` in tish_compile/src/resolve.rs.
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        all,
+                        from,
+                        ..
+                    } => {
+                        let dir = parent_dir(&module.path);
+                        let dep = resolve_import_to_key_for_cycle(from, dir, &path_to_idx)
+                            .ok()
+                            .and_then(|key| path_to_idx.get(&key).copied())
+                            .map(|dep_idx| module_exports[dep_idx].clone());
+                        if let Some(dep) = dep {
+                            if *all {
+                                for (k, v) in &dep {
+                                    module_exports[idx]
+                                        .entry(k.clone())
+                                        .or_insert_with(|| v.clone());
+                                }
+                            }
+                            for spec in specifiers {
+                                if let ImportSpecifier::Named { name, alias, .. } = spec {
+                                    if let Some(binding) = dep.get(name.as_ref()) {
+                                        let export_name =
+                                            alias.as_deref().unwrap_or(name.as_ref()).to_string();
+                                        module_exports[idx].insert(export_name, binding.clone());
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -440,6 +489,10 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                             span: espan,
                         });
                     }
+                    // #305: re-export emits no code — `module_exports` already maps the re-exported
+                    // names to the dep's bindings (in scope in the flattened bundle), so downstream
+                    // imports resolve directly. Nothing to push here.
+                    ExportDeclaration::ReExport { .. } => {}
                 },
                 _ => statements.push(stmt.clone()),
             }
@@ -471,4 +524,49 @@ mod tests {
         let program = merge_modules_virtual(modules).unwrap();
         assert!(!program.statements.is_empty());
     }
+
+    #[test]
+    fn test_resolve_virtual_reexport_alias() {
+        // #305: `export { add as plus } from "./dep"` re-exports dep's `add` as `plus`; a downstream
+        // `import { plus }` must resolve to dep's binding. Regression guard: the merge previously did
+        // not handle `ExportDeclaration::ReExport` (E0004 build failure), and discovery did not follow
+        // the re-export edge (so a dep reached only via re-export was never loaded).
+        let mut files = HashMap::new();
+        files.insert(
+            "dep.tish".to_string(),
+            "export fn add(a, b) { return a + b }".to_string(),
+        );
+        files.insert(
+            "mid.tish".to_string(),
+            "export { add as plus } from \"./dep.tish\"".to_string(),
+        );
+        files.insert(
+            "main.tish".to_string(),
+            "import { plus } from \"./mid.tish\"\nconsole.log(plus(1, 2))".to_string(),
+        );
+        let modules = resolve_virtual("main.tish", &files).unwrap();
+        // dep.tish is reached ONLY via mid's re-export → discovery must have loaded it.
+        assert!(
+            modules.iter().any(|m| m.path == "dep.tish"),
+            "re-exported dep should be discovered and loaded"
+        );
+        detect_cycles_virtual(&modules).unwrap();
+        let program = merge_modules_virtual(modules).unwrap();
+        let has_add_fn = program
+            .statements
+            .iter()
+            .any(|s| matches!(s, Statement::FunDecl { name, .. } if name.as_ref() == "add"));
+        let binds_plus_to_add = program.statements.iter().any(|s| {
+            matches!(
+                s,
+                Statement::VarDecl { name, init: Some(Expr::Ident { name: src, .. }), .. }
+                if name.as_ref() == "plus" && src.as_ref() == "add"
+            )
+        });
+        assert!(has_add_fn, "dep's `add` fn should be in the merged bundle");
+        assert!(
+            binds_plus_to_add,
+            "import of re-exported `plus` should bind to dep's `add`"
+        );
+    }
 }

package/crates/tish_core/Cargo.toml

@@ -25,6 +25,10 @@ smallvec = "1"
 indexmap = "2"
 # Fast integer→decimal for the JSON.stringify number fast-path (already in the workspace lock).
 itoa = "1"
+# Fast shortest-float→decimal for the number→string general path (JSON/template/log). ryu writes the
+# shortest round-trip digits straight to a buffer with none of `core::fmt`'s `{:e}` Formatter overhead
+# (profiled as ~40% of JSON.stringify self-time on numeric payloads). Already in the workspace lock.
+ryu = "1"
 fancy-regex = { version = "0.17.0", optional = true }
 # Only under `send-values` (the Arc<Mutex> path): parking_lot's uncontended lock is a
 # single atomic with no pthread syscall — profiled as a top cost on object/array access.

package/crates/tish_core/src/json.rs

@@ -80,10 +80,31 @@ pub fn json_parse(json: &str) -> Result<Value, String> {
 /// per-node `String` only to copy + drop it on the way back up. For a
 /// 20-row TFB `/queries` response (~40 numbers, 2 keys × 20 = ~80 string
 /// ops) that saves dozens of small allocations per request.
+fn json_stringify_capacity_hint(value: &Value) -> usize {
+    match value {
+        Value::Array(arr) => {
+            let n = arr.borrow().len();
+            if n > 64 {
+                // json_roundtrip / large API payloads: ~80–100 B per row is typical.
+                n.saturating_mul(96).max(256)
+            } else {
+                256
+            }
+        }
+        Value::Object(obj) => {
+            let n = obj.borrow().strings.len();
+            if n > 32 {
+                n.saturating_mul(128).max(256)
+            } else {
+                256
+            }
+        }
+        _ => 256,
+    }
+}
+
 pub fn json_stringify(value: &Value) -> String {
-    // 256 B is enough for typical TFB responses (`/db` is 31 B,
-    // `/queries=20` is ~700 B). Larger payloads reallocate normally.
-    let mut buf = String::with_capacity(256);
+    let mut buf = String::with_capacity(json_stringify_capacity_hint(value));
     json_stringify_into(&mut buf, value);
     buf
 }
@@ -91,7 +112,39 @@ pub fn json_stringify(value: &Value) -> String {
 /// Append a JSON-stringified `value` to `buf`. Used by JSON.stringify for
 /// the recursive case so we don't pay for an intermediate `String` per
 /// node.
+///
+/// Cyclic object graphs (`a.self = a`) are detected and — matching JS, which throws
+/// `TypeError: Converting circular structure to JSON` — set a pending throw and emit `null` for the
+/// back-reference instead of recursing forever (#381: this was an unrecoverable thread hang, directly
+/// reachable from HTTP response serialization).
 pub fn json_stringify_into(buf: &mut String, value: &Value) {
+    // Track the CURRENT ancestor path only (not all-visited): a node repeated across sibling branches
+    // is a legal DAG and must serialize twice; only a back-edge to an ancestor is a cycle.
+    let mut ancestors: Vec<*const ()> = Vec::new();
+    json_stringify_into_guarded(buf, value, &mut ancestors);
+}
+
+/// Set the JS "circular structure" TypeError as the pending throw (once). The `{ name, message }`
+/// shape matches node (`e.name === "TypeError"`, `e.message === "Converting circular structure to
+/// JSON"`) and tish's own thrown-error convention (`construct_builtin::error_object`, the recursion
+/// `RangeError` from [`crate::stack_overflow_error`]) — the previous `{ error: <msg> }` shape left
+/// `e.name` null in a catch block, diverging from node.
+fn signal_circular_json_throw() {
+    if !crate::has_pending_throw() {
+        crate::set_pending_throw(Value::object_from_pairs([
+            (
+                std::sync::Arc::from("name"),
+                Value::String("TypeError".into()),
+            ),
+            (
+                std::sync::Arc::from("message"),
+                Value::String("Converting circular structure to JSON".into()),
+            ),
+        ]));
+    }
+}
+
+fn json_stringify_into_guarded(buf: &mut String, value: &Value, ancestors: &mut Vec<*const ()>) {
     match value {
         Value::Null => buf.push_str("null"),
         Value::Bool(true) => buf.push_str("true"),
@@ -103,15 +156,24 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
             buf.push('"');
         }
         Value::Array(arr) => {
+            let ptr = arr.as_ptr();
+            if ancestors.contains(&ptr) {
+                signal_circular_json_throw();
+                buf.push_str("null");
+                return;
+            }
+            ancestors.push(ptr);
             let borrowed = arr.borrow();
             buf.push('[');
             for (i, item) in borrowed.iter().enumerate() {
                 if i > 0 {
                     buf.push(',');
                 }
-                json_stringify_into(buf, item);
+                json_stringify_into_guarded(buf, item, ancestors);
             }
             buf.push(']');
+            drop(borrowed);
+            ancestors.pop();
         }
         Value::NumberArray(arr) => {
             let borrowed = arr.borrow();
@@ -125,6 +187,13 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
             buf.push(']');
         }
         Value::Object(obj) => {
+            let ptr = obj.as_ptr();
+            if ancestors.contains(&ptr) {
+                signal_circular_json_throw();
+                buf.push_str("null");
+                return;
+            }
+            ancestors.push(ptr);
             let borrowed = obj.borrow();
             // Iterate in insertion order (PropMap preserves it) — matches JS/Node
             // and `Object.keys`. No intermediate key Vec, no sort: one fewer
@@ -137,9 +206,11 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
                 buf.push('"');
                 escape_json_string_into(buf, key);
                 buf.push_str("\":");
-                json_stringify_into(buf, val);
+                json_stringify_into_guarded(buf, val, ancestors);
             }
             buf.push('}');
+            drop(borrowed);
+            ancestors.pop();
         }
         Value::Function(_) | Value::Promise(_) | Value::Opaque(_) | Value::Symbol(_) => {
             buf.push_str("null");
@@ -477,6 +548,34 @@ fn parse_object<'a>(
 mod tests {
     use super::*;
 
+    /// #381: a self-referential array must NOT loop forever — `JSON.stringify` terminates, emits a
+    /// finite string, and (matching JS) leaves a pending TypeError. The test *completing* is itself
+    /// the assertion that the former infinite hang is gone.
+    #[test]
+    fn json_stringify_cyclic_array_terminates_and_throws() {
+        let _ = crate::take_pending_throw(); // isolate from any prior thread-local throw
+        let a = Value::Array(crate::VmRef::new(Vec::new()));
+        if let Value::Array(inner) = &a {
+            inner.borrow_mut().push(a.clone()); // a = [a]
+        }
+        let s = json_stringify(&a);
+        assert_eq!(s, "[null]", "back-reference serializes as null, finite output");
+        assert!(crate::has_pending_throw(), "cyclic stringify must set a pending TypeError");
+        let _ = crate::take_pending_throw(); // clean up thread-local for other tests
+    }
+
+    /// A shared (non-cyclic) node repeated across sibling branches is a legal DAG and must serialize
+    /// twice — the ancestor-only tracking must NOT misflag it as a cycle.
+    #[test]
+    fn json_stringify_shared_dag_node_is_not_a_cycle() {
+        let _ = crate::take_pending_throw();
+        let shared = Value::Array(crate::VmRef::new(vec![Value::Number(1.0)]));
+        let root = Value::Array(crate::VmRef::new(vec![shared.clone(), shared.clone()]));
+        let s = json_stringify(&root);
+        assert_eq!(s, "[[1],[1]]", "a shared node is a DAG, not a cycle");
+        assert!(!crate::has_pending_throw(), "a DAG must NOT throw");
+    }
+
     #[test]
     fn test_parse_primitives() {
         assert!(matches!(json_parse("null").unwrap(), Value::Null));

package/crates/tish_core/src/lib.rs

@@ -40,3 +40,177 @@ pub fn process_argv() -> Vec<String> {
         None => std::env::args().collect(),
     }
 }
+
+/// #303 — a thrown JS value parked while it unwinds across a boundary that can't carry a `Result`.
+///
+/// The native value-fn ABI is `Fn(&[Value]) -> Value`, and `Callable::call` likewise returns a bare
+/// `Value`, so a `throw` crossing such a boundary can't ride a `Result`. It is parked here and picked
+/// up at the next checkpoint: native codegen checks it after each call; the VM checks it after each
+/// `Callable::call`; and the shared array builtins (`forEach`/`map`/`sort`/…) check it between
+/// elements so they stop iterating promptly instead of running the callback for the rest of the
+/// array. The slot lives in `tishlang_core` (rather than `tishlang_runtime`) so `tishlang_builtins`
+/// can poll it without a `builtins -> runtime` dependency cycle; `tishlang_runtime` and `tishlang_vm`
+/// share this one slot. First-throw-wins; drained exactly once by [`take_pending_throw`] at the frame
+/// that converts it back into a `Result`.
+thread_local! {
+    static PENDING_THROW: std::cell::RefCell<Option<Value>> = const { std::cell::RefCell::new(None) };
+}
+
+/// Park a thrown value to propagate across a non-`Result` boundary. First-throw-wins: if one is
+/// already pending (an erroneous continuation reached a second throw before the slot was drained),
+/// keep the first — that is the throw JS would have raised.
+pub fn set_pending_throw(v: Value) {
+    PENDING_THROW.with(|c| {
+        let mut slot = c.borrow_mut();
+        if slot.is_none() {
+            *slot = Some(v);
+        }
+    });
+}
+
+/// Is a thrown value waiting to propagate?
+pub fn has_pending_throw() -> bool {
+    PENDING_THROW.with(|c| c.borrow().is_some())
+}
+
+/// Take the parked thrown value, clearing the slot (drains it exactly once).
+pub fn take_pending_throw() -> Option<Value> {
+    PENDING_THROW.with(|c| c.borrow_mut().take())
+}
+
+thread_local! {
+    /// Current user-function call depth for the bytecode VM. The VM's recursive path builds a fresh
+    /// `Vm` per call (so no shared struct field can accumulate) and its `Callable::call` signature is
+    /// fixed — a thread-local is the VM's equivalent of the interpreter's shared `Rc<Cell>` counter.
+    /// Lives here (not `tish_vm`) beside `PENDING_THROW` for the same layering reason. #381
+    static CALL_DEPTH: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// Enter one VM call frame; returns the new depth. Pair every call with [`dec_call_depth`].
+#[inline]
+pub fn inc_call_depth() -> usize {
+    CALL_DEPTH.with(|c| {
+        let d = c.get() + 1;
+        c.set(d);
+        d
+    })
+}
+
+/// Leave one VM call frame.
+#[inline]
+pub fn dec_call_depth() {
+    CALL_DEPTH.with(|c| c.set(c.get().saturating_sub(1)));
+}
+
+/// Default recursion ceiling shared by every backend that counts call depth (#381). Chosen with the
+/// interpreter: comfortably deep for real programs, but reached long before counted recursion can
+/// exhaust memory or the stack.
+pub const DEFAULT_MAX_CALL_DEPTH: usize = 20_000;
+
+thread_local! {
+    // The recursion ceiling, lazily initialized from `TISH_MAX_CALL_DEPTH` (0 = uninitialized). A
+    // thread-local Cell (not OnceLock) so tests can override it per-thread without racing the
+    // process-wide env. Shared by the VM's guard and the native backend's boxed-call guard. #381
+    static MAX_CALL_DEPTH: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// The recursion ceiling for depth-counting guards: user-fn calls deeper than this raise a catchable
+/// `RangeError` instead of overflowing the native stack. `TISH_MAX_CALL_DEPTH` overrides (default
+/// [`DEFAULT_MAX_CALL_DEPTH`]). #381
+pub fn max_call_depth() -> usize {
+    MAX_CALL_DEPTH.with(|c| {
+        let v = c.get();
+        if v != 0 {
+            return v;
+        }
+        let init = std::env::var("TISH_MAX_CALL_DEPTH")
+            .ok()
+            .and_then(|s| s.parse::<usize>().ok())
+            .filter(|&n| n > 0)
+            .unwrap_or(DEFAULT_MAX_CALL_DEPTH);
+        c.set(init);
+        init
+    })
+}
+
+/// Test hook: pin the ceiling for the current thread (bypasses the env read).
+pub fn set_max_call_depth_for_test(n: usize) {
+    MAX_CALL_DEPTH.with(|c| c.set(n));
+}
+
+/// The catchable `RangeError` raised when a recursion guard trips. Built by hand (`tishlang_core`
+/// sits below `tishlang_builtins`) but shape-identical to `construct_builtin::error_object`:
+/// a `{ name, message }` object — keep the two in lock-step.
+pub fn stack_overflow_error() -> Value {
+    let mut e = ObjectMap::default();
+    e.insert(
+        std::sync::Arc::from("name"),
+        Value::String("RangeError".into()),
+    );
+    e.insert(
+        std::sync::Arc::from("message"),
+        Value::String("Maximum call stack size exceeded".into()),
+    );
+    Value::object(e)
+}
+
+/// A catchable `TypeError` for calling a non-callable value — the `{ name, message }` shape matches
+/// the VM/interpreter/node (`e.name === "TypeError"`). Used to PARK a pending throw (#381) instead of
+/// aborting the process, so `value_call` on a non-function surfaces as a catchable error at the next
+/// pending-throw checkpoint rather than an uncatchable native panic.
+pub fn not_a_function_error(message: impl Into<String>) -> Value {
+    let mut e = ObjectMap::default();
+    e.insert(
+        std::sync::Arc::from("name"),
+        Value::String("TypeError".into()),
+    );
+    e.insert(
+        std::sync::Arc::from("message"),
+        Value::String(message.into().into()),
+    );
+    Value::object(e)
+}
+
+/// A catchable `TypeError` for reading a property/index of the nullish value — the `{ name, message }`
+/// shape matches the VM/interpreter/node (`e.name === "TypeError"`). Used to PARK a pending throw in
+/// the native/runtime `get_prop`/`get_index` null arm (#425), so `null.length` / `null[0]` surface a
+/// catchable error at the next pending-throw checkpoint instead of silently reading back `null`.
+pub fn cannot_read_property_error(prop: &str) -> Value {
+    let mut e = ObjectMap::default();
+    e.insert(
+        std::sync::Arc::from("name"),
+        Value::String("TypeError".into()),
+    );
+    e.insert(
+        std::sync::Arc::from("message"),
+        Value::String(format!("Cannot read property '{}' of null", prop).into()),
+    );
+    Value::object(e)
+}
+
+/// RAII frame for the depth-counting recursion guard: holding one means the depth was incremented;
+/// dropping it decrements, so early returns in generated code can't leak a level. #381
+pub struct CallDepthGuard(());
+
+impl Drop for CallDepthGuard {
+    #[inline]
+    fn drop(&mut self) {
+        dec_call_depth();
+    }
+}
+
+/// Enter a counted user-fn call frame, or trip the recursion guard: past [`max_call_depth`] this
+/// parks the catchable stack-overflow `RangeError` in the pending-throw slot and returns `None` —
+/// the caller just returns its frame's dummy value (`Value::Null`) and the throw surfaces at the
+/// next pending-throw checkpoint. The native backend emits this at the top of every boxed user-fn
+/// closure. #381
+#[inline]
+pub fn enter_call_guarded() -> Option<CallDepthGuard> {
+    let depth = inc_call_depth();
+    if depth > max_call_depth() {
+        dec_call_depth();
+        set_pending_throw(stack_overflow_error());
+        return None;
+    }
+    Some(CallDepthGuard(()))
+}

package/crates/tish_core/src/shape.rs

@@ -12,7 +12,6 @@
 //! `PropMap` on a cache miss). Phase 1b will attach the ordered key list to each shape so objects can
 //! drop per-object key storage entirely (the butterfly representation).
 
-use std::collections::HashMap;
 use std::sync::{Arc, OnceLock, RwLock};
 
 /// Identity of an object's ordered key-set.
@@ -27,9 +26,12 @@ pub const EMPTY_SHAPE: ShapeId = 0;
 pub const DICT_SHAPE: ShapeId = u32::MAX;
 
 /// One node in the structure-transition tree: from this shape, adding a given key yields a child shape.
+/// Edges are keyed by an `ahash` map, not the default SipHash one: `transition` is on the hot path of
+/// every object construction (and `JSON.parse` — profiled as ~16% of parse, almost all SipHash), and
+/// ahash is ~2–3× faster on short string keys. Random-seeded per process, so no HashDoS regression.
 #[derive(Default)]
 struct ShapeNode {
-    transitions: HashMap<Arc<str>, ShapeId>,
+    transitions: ahash::AHashMap<Arc<str>, ShapeId>,
 }
 
 struct Registry {