@tishlang/tish-format 2.16.13 → 2.35.0

package/crates/tish_compile/src/infer.rs

@@ -1220,7 +1220,7 @@ fn check_returns_numeric(s: &Statement, ctx: &InferCtx, ok: &mut bool) {
                 check_returns_numeric(e, ctx, ok);
             }
         }
-        While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } => {
+        While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } | ForIn { body, .. } => {
             check_returns_numeric(body, ctx, ok);
         }
         For { init, body, .. } => {
@@ -1319,7 +1319,12 @@ fn count_uses_stmt(s: &Statement, f: &str, calls: &mut usize, others: &mut usize
             }
             count_uses_stmt(body, f, calls, others);
         }
-        ForOf { iterable, body, .. } => {
+        ForOf { iterable, body, .. }
+        | ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             count_uses_expr(iterable, f, calls, others);
             count_uses_stmt(body, f, calls, others);
         }
@@ -1522,7 +1527,7 @@ fn stmt_contains_fundecl(s: &Statement) -> bool {
             stmt_contains_fundecl(then_branch)
                 || else_branch.as_ref().is_some_and(|e| stmt_contains_fundecl(e))
         }
-        While { body, .. } | DoWhile { body, .. } | For { body, .. } | ForOf { body, .. } => {
+        While { body, .. } | DoWhile { body, .. } | For { body, .. } | ForOf { body, .. } | ForIn { body, .. } => {
             stmt_contains_fundecl(body)
         }
         Try { body, catch_body, finally_body, .. } => {
@@ -1574,7 +1579,12 @@ fn walk_exprs_stmt_full(s: &Statement, f: &mut impl FnMut(&Expr)) {
             }
             walk_exprs_stmt_full(body, f);
         }
-        ForOf { iterable, body, .. } => {
+        ForOf { iterable, body, .. }
+        | ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             walk_exprs_expr(iterable, f);
             walk_exprs_stmt_full(body, f);
         }
@@ -1639,7 +1649,7 @@ fn count_returns(s: &Statement) -> usize {
             count_returns(then_branch)
                 + else_branch.as_ref().map_or(0, |e| count_returns(e))
         }
-        While { body, .. } | DoWhile { body, .. } | For { body, .. } | ForOf { body, .. } => {
+        While { body, .. } | DoWhile { body, .. } | For { body, .. } | ForOf { body, .. } | ForIn { body, .. } => {
             count_returns(body)
         }
         Try { body, catch_body, finally_body, .. } => {
@@ -2694,7 +2704,7 @@ fn seed_numeric_locals(s: &Statement, hyp: &mut InferCtx) {
             }
             seed_numeric_locals(body, hyp);
         }
-        While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } => {
+        While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } | ForIn { body, .. } => {
             seed_numeric_locals(body, hyp)
         }
         _ => {}
@@ -3649,7 +3659,7 @@ fn collect_return_shapes(
                 }
             }
         }
-        For { body, .. } | While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } => {
+        For { body, .. } | While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } | ForIn { body, .. } => {
             if !collect_return_shapes(body, pctx, found, ok) {
                 return false;
             }
@@ -3916,7 +3926,7 @@ fn collect_element_aliases(s: &Statement, p: &str, out: &mut HashSet<String>) {
             }
             collect_element_aliases(body, p, out);
         }
-        While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } => {
+        While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } | ForIn { body, .. } => {
             collect_element_aliases(body, p, out)
         }
         _ => {}
@@ -4241,7 +4251,12 @@ fn walk_exprs_stmt(s: &Statement, f: &mut impl FnMut(&Expr)) {
             }
             walk_exprs_stmt(body, f);
         }
-        ForOf { iterable, body, .. } => {
+        ForOf { iterable, body, .. }
+        | ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             walk_exprs_expr(iterable, f);
             walk_exprs_stmt(body, f);
         }
@@ -4354,7 +4369,7 @@ fn collect_body_struct_locals(
                 collect_body_struct_locals(e, analysis, out);
             }
         }
-        For { body, .. } | While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } => {
+        For { body, .. } | While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } | ForIn { body, .. } => {
             collect_body_struct_locals(body, analysis, out)
         }
         _ => {}
@@ -4388,7 +4403,7 @@ fn find_array_return(s: &Statement, locals: &HashMap<String, String>) -> Option<
         }
         If { then_branch, else_branch, .. } => find_array_return(then_branch, locals)
             .or_else(|| else_branch.as_ref().and_then(|e| find_array_return(e, locals))),
-        For { body, .. } | While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } => {
+        For { body, .. } | While { body, .. } | DoWhile { body, .. } | ForOf { body, .. } | ForIn { body, .. } => {
             find_array_return(body, locals)
         }
         _ => None,

package/crates/tish_compile/src/resolve.rs

@@ -49,17 +49,23 @@ pub struct NativeBuildArtifacts {
     pub native_init: std::collections::HashMap<String, NativeModuleInit>,
 }
 
-/// Node-compatible aliases for built-in modules (fs -> tish:fs, etc.).
+/// Node-compatible aliases for built-in modules (fs -> tish:fs, etc.). The `node:` prefix
+/// (e.g. `node:fs`, `node:fs/promises`) is stripped before lookup.
 const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("fs", "tish:fs"),
+    ("fs/promises", "tish:fs/promises"),
     ("http", "tish:http"),
     ("timers", "tish:timers"),
     ("process", "tish:process"),
     ("ws", "tish:ws"),
+    ("tty", "tish:tty"),
 ];
 
-/// Normalize built-in spec to canonical form. E.g. "fs" -> "tish:fs".
+/// Normalize built-in spec to canonical form. Handles the Node `node:` prefix
+/// (`node:fs` -> `tish:fs`, `node:fs/promises` -> `tish:fs/promises`) and bare aliases.
 pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
+    // Strip a leading `node:` so `node:fs` resolves the same as `fs`.
+    let spec = spec.strip_prefix("node:").unwrap_or(spec);
     if spec.starts_with("tish:") {
         return Some(spec.to_string());
     }
@@ -71,10 +77,20 @@ pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
 
 /// Built-in modules that come from tishlang_runtime, not from package.json.
 pub fn is_builtin_native_spec(spec: &str) -> bool {
+    let spec = spec.strip_prefix("node:").unwrap_or(spec);
     matches!(
         spec,
-        "tish:fs" | "tish:http" | "tish:timers" | "tish:process" | "tish:ws" | "tish:tty"
-    ) || matches!(spec, "fs" | "http" | "timers" | "process" | "ws" | "tty")
+        "tish:fs"
+            | "tish:fs/promises"
+            | "tish:http"
+            | "tish:timers"
+            | "tish:process"
+            | "tish:ws"
+            | "tish:tty"
+    ) || matches!(
+        spec,
+        "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty"
+    )
 }
 
 /// Resolve all native imports in a merged program via package.json lookup.
@@ -238,9 +254,12 @@ pub fn program_uses_document(program: &Program) -> bool {
                     || update.as_ref().is_some_and(expr_uses_document)
                     || stmt_uses_document(body)
             }
-            Statement::ForOf { iterable, body, .. } => {
-                expr_uses_document(iterable) || stmt_uses_document(body)
-            }
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => expr_uses_document(iterable) || stmt_uses_document(body),
             Statement::Switch {
                 expr,
                 cases,
@@ -890,7 +909,8 @@ fn stmt_module_dep(stmt: &Statement) -> Option<&std::sync::Arc<str>> {
     match stmt {
         Statement::Import { from, .. } => Some(from),
         Statement::Export { declaration, .. } => match declaration.as_ref() {
-            ExportDeclaration::ReExport { from, .. } => Some(from),
+            // A local named export (`export { a }`, from=None) has no module dependency.
+            ExportDeclaration::ReExport { from, .. } => from.as_ref(),
             _ => None,
         },
         _ => None,
@@ -951,10 +971,15 @@ fn load_module_recursive(
 ///
 /// Scoped npm packages (`@scope/pkg`) are merged as Tish source unless imported via `tish:…`.
 pub fn is_native_import(spec: &str) -> bool {
+    // A leading `node:` (node:fs, node:fs/promises) resolves the same as the bare form.
+    let spec = spec.strip_prefix("node:").unwrap_or(spec);
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
         || spec.starts_with("ffi:")
-        || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
+        || matches!(
+            spec,
+            "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty"
+        )
 }
 
 /// True for `ffi:…` specs (portable C-ABI cdylib extensions, loadable on every backend). The
@@ -1160,6 +1185,11 @@ fn has_cycle_from(
 pub struct MergedProgram {
     pub program: Program,
     pub statement_sources: Vec<PathBuf>,
+    /// #295: the ENTRY module's exported `(local_name, exported_name)` pairs, excluding `default`
+    /// (handled separately as `export default`). Merge unwraps exports into plain top-level
+    /// declarations, so `--target js --format bundle` re-emits these as a trailing `export { … }` to
+    /// produce a valid ES module. Sorted by local name for deterministic output.
+    pub entry_exports: Vec<(String, String)>,
 }
 
 fn merge_push(
@@ -1465,6 +1495,12 @@ pub(crate) fn rewrite_stmt_scope(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            object: iterable,
+            body,
+            ..
         } => {
             rewrite_expr_scope(iterable, active);
             let mut child = active.clone();
@@ -1696,6 +1732,14 @@ pub(crate) fn rewrite_expr_scope(expr: &mut Expr, active: &HashMap<String, Arc<s
 /// Import statements are rewritten as bindings from already-emitted dep exports.
 /// Export statements are unwrapped (the inner declaration is emitted).
 pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram, String> {
+    // #469: give the ENTRY module a Go/Rust/Swift-style `main` entry point. The entry is the last
+    // module (post-order dependency load order), and this runs BEFORE private-binding isolation so the
+    // synthetic `main()` call is renamed in lockstep with the `main` declaration if isolation renames
+    // it. Every backend consumes the merged program, so this keeps interp/vm/native/js consistent.
+    if let Some(entry) = modules.last_mut() {
+        tishlang_ast::append_main_entry(&mut entry.program.statements);
+    }
+
     // #97: isolate module-private top-level bindings before they are flattened together.
     isolate_private_top_level_bindings(&mut modules);
 
@@ -1730,7 +1774,7 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                     ExportDeclaration::ReExport {
                         specifiers,
                         all,
-                        from,
+                        from: Some(from),
                         ..
                     } => {
                         let dir = module.path.parent().unwrap_or_else(|| Path::new("."));
@@ -1758,6 +1802,22 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                             }
                         }
                     }
+                    // #415 local named export (`export { a, b as c }`, no `from`): each specifier
+                    // exports an already-declared LOCAL top-level binding, mapping export-name -> that
+                    // binding. (`isolate_private_top_level_bindings` keeps exported names un-renamed.)
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        from: None,
+                        ..
+                    } => {
+                        for spec in specifiers {
+                            if let ImportSpecifier::Named { name, alias, .. } = spec {
+                                let export_name =
+                                    alias.as_deref().unwrap_or(name.as_ref()).to_string();
+                                module_exports[idx].insert(export_name, name.to_string());
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -1956,9 +2016,26 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
             }
         }
     }
+    // #295: capture the ENTRY module's exports (the entry is last — deps are emitted first). Merge
+    // already built `module_exports[idx]` as exported_name -> local_binding; re-express as
+    // (local, exported) for the JS bundle emitter, excluding `default` (emitted as `export default`).
+    let entry_exports: Vec<(String, String)> = modules
+        .len()
+        .checked_sub(1)
+        .map(|last| {
+            let mut v: Vec<(String, String)> = module_exports[last]
+                .iter()
+                .filter(|(exported, _)| exported.as_str() != "default")
+                .map(|(exported, local)| (local.clone(), exported.clone()))
+                .collect();
+            v.sort();
+            v
+        })
+        .unwrap_or_default();
     Ok(MergedProgram {
         program: Program { statements },
         statement_sources,
+        entry_exports,
     })
 }
 

package/crates/tish_compile_js/src/codegen.rs

@@ -376,6 +376,19 @@ impl Codegen {
                 self.writeln(&format!("for (const {} of {})", escaped, it));
                 self.emit_js_control_body(body)?;
             }
+            Statement::ForIn {
+                name,
+                object,
+                body,
+                ..
+            } => {
+                // Native JS `for-in` — iterates own enumerable keys (#413). tish objects have no
+                // prototype chain, so this matches the key-enumeration the other backends perform.
+                let escaped = Self::escape_ident(name.as_ref());
+                let obj = self.emit_expr(object)?;
+                self.writeln(&format!("for (const {} in {})", escaped, obj));
+                self.emit_js_control_body(body)?;
+            }
             Statement::Return { value, .. } => {
                 if let Some(v) = value {
                     let e = self.emit_expr(v)?;
@@ -677,6 +690,14 @@ impl Codegen {
             }
             Expr::Call { callee, args, .. } => {
                 let c = self.emit_expr(callee)?;
+                // An arrow-function callee (an IIFE — `(function(x){…})(n)` lowers to an arrow, as does
+                // `((x)=>…)(n)`) must be parenthesized: without it the call `(args)` binds to the arrow
+                // BODY, not the whole arrow — a `SyntaxError` for a block body, wrong result otherwise.
+                let c = if matches!(&**callee, Expr::ArrowFunction { .. }) {
+                    format!("({})", c)
+                } else {
+                    c
+                };
                 let arg_strs: Result<Vec<_>, _> =
                     args.iter().map(|a| self.emit_call_arg(a)).collect();
                 let arg_strs = arg_strs?.join(", ");
@@ -889,7 +910,9 @@ impl Codegen {
                 let val = self.emit_expr(value)?;
                 format!("({}[{}] = {})", obj, idx, val)
             }
-            Expr::ArrowFunction { params, body, .. } => {
+            Expr::ArrowFunction {
+                async_, params, body, ..
+            } => {
                 let ps = self.emit_params(params, None)?;
                 let body_str = match body {
                     ArrowBody::Expr(e) => self.emit_expr(e)?,
@@ -905,10 +928,11 @@ impl Codegen {
                         block
                     }
                 };
+                let prefix = if *async_ { "async " } else { "" }; // #428
                 if matches!(body, ArrowBody::Expr(_)) {
-                    format!("({}) => ({})", ps, body_str)
+                    format!("{}({}) => ({})", prefix, ps, body_str)
                 } else {
-                    format!("({}) => {}", ps, body_str)
+                    format!("{}({}) => {}", prefix, ps, body_str)
                 }
             }
             Expr::TemplateLiteral { quasis, exprs, .. } => {
@@ -1044,29 +1068,42 @@ impl Codegen {
                 from,
                 ..
             } => {
-                let spec = rewrite_import_to_js(
-                    from.as_ref(),
-                    &self.module_path,
-                    &self.project_root,
-                    self.import_rewrite,
-                )?;
-                if *all {
-                    self.writeln(&format!("export * from {:?};", spec));
-                } else {
-                    let mut parts: Vec<String> = Vec::new();
-                    for s in specifiers {
-                        if let ImportSpecifier::Named { name, alias, .. } = s {
-                            match alias {
-                                Some(a) => parts.push(format!(
-                                    "{} as {}",
-                                    Self::escape_ident(name.as_ref()),
-                                    Self::escape_ident(a.as_ref())
-                                )),
-                                None => parts.push(Self::escape_ident(name.as_ref()).to_string()),
-                            }
+                let mut parts: Vec<String> = Vec::new();
+                for s in specifiers {
+                    if let ImportSpecifier::Named { name, alias, .. } = s {
+                        match alias {
+                            Some(a) => parts.push(format!(
+                                "{} as {}",
+                                Self::escape_ident(name.as_ref()),
+                                Self::escape_ident(a.as_ref())
+                            )),
+                            None => parts.push(Self::escape_ident(name.as_ref()).to_string()),
+                        }
+                    }
+                }
+                match from {
+                    // Re-export from another module: `export … from "…"`.
+                    Some(from) => {
+                        let spec = rewrite_import_to_js(
+                            from.as_ref(),
+                            &self.module_path,
+                            &self.project_root,
+                            self.import_rewrite,
+                        )?;
+                        if *all {
+                            self.writeln(&format!("export * from {:?};", spec));
+                        } else {
+                            self.writeln(&format!(
+                                "export {{ {} }} from {:?};",
+                                parts.join(", "),
+                                spec
+                            ));
                         }
                     }
-                    self.writeln(&format!("export {{ {} }} from {:?};", parts.join(", "), spec));
+                    // #415 local named export — no `from` clause.
+                    None => {
+                        self.writeln(&format!("export {{ {} }};", parts.join(", ")));
+                    }
                 }
             }
         }
@@ -1215,6 +1252,7 @@ fn compile_project_js_inner(
         merged.program.clone()
     };
     let stmt_sources = merged.statement_sources;
+    let entry_exports = merged.entry_exports; // #295: entry module's named exports for the bundle
     let default_export = program.statements.iter().find_map(|s| {
         if let Statement::VarDecl { name, .. } = s {
             let n = name.as_ref();
@@ -1254,6 +1292,26 @@ fn compile_project_js_inner(
         gen.emit_program(&program, None, None)?;
     }
     let mut js = gen.output;
+    // #295: re-emit the entry module's named exports as a real ES `export { … }` so the bundle is a
+    // valid ES module (previously only `export default` was emitted; named `export fn/let/{…}` were
+    // silently dropped, forcing downstream regex post-processing).
+    if !entry_exports.is_empty() {
+        let parts: Vec<String> = entry_exports
+            .iter()
+            .map(|(local, exported)| {
+                if local == exported {
+                    Codegen::escape_ident(local)
+                } else {
+                    format!(
+                        "{} as {}",
+                        Codegen::escape_ident(local),
+                        Codegen::escape_ident(exported)
+                    )
+                }
+            })
+            .collect();
+        js.push_str(&format!("\nexport {{ {} }};\n", parts.join(", ")));
+    }
     if let Some(name) = default_export {
         js.push_str(&format!("\nexport default {};\n", name));
     }

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -167,6 +167,33 @@ mod tests {
         let _ = std::fs::remove_file(&path);
     }
 
+    /// #295: `--target js --format bundle` must re-emit the entry module's named exports as a real ES
+    /// `export { … }` (previously only `export default` surfaced; `export fn/const/{…}` were silently
+    /// dropped, forcing downstream regex post-processing of every bundle).
+    #[test]
+    fn bundle_emits_named_exports() {
+        // `tempfile::tempdir()` (RAII, unique dir) rather than a fixed `std::env::temp_dir()` path.
+        let dir = tempfile::tempdir().expect("tempdir");
+        let path = dir.path().join("entry.tish");
+        let src = "export fn mountFoo(h) { return h }\n\
+                   export const VERSION = \"1\"\n\
+                   fn helper() { return 2 }\n\
+                   export { helper as helperExported }\n\
+                   export default 42\n";
+        std::fs::write(&path, src).unwrap();
+        let js = compile_project_with_jsx(&path, Some(dir.path()), false)
+            .expect("compile_project_with_jsx failed");
+        assert!(
+            js.contains("export { VERSION, helper as helperExported, mountFoo };"),
+            "bundle must emit named exports, got:\n{}",
+            &js[js.len().saturating_sub(300)..]
+        );
+        assert!(
+            js.contains("export default __default_0;"),
+            "bundle must still emit the default export"
+        );
+    }
+
     #[test]
     fn jsx_never_emits_vdom_helpers_or_prelude_flags() {
         let src = r#"fn X() { return <div class="x">{"a"}</div> }"#;

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -106,7 +106,8 @@ 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),
+            // A local named export (`export { a }`, from=None) has no module dependency.
+            ExportDeclaration::ReExport { from, .. } => from.as_deref(),
             _ => None,
         },
         _ => None,
@@ -314,7 +315,7 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                     ExportDeclaration::ReExport {
                         specifiers,
                         all,
-                        from,
+                        from: Some(from),
                         ..
                     } => {
                         let dir = parent_dir(&module.path);
@@ -341,6 +342,20 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                             }
                         }
                     }
+                    // #415 local named export (no `from`): map each export name to the local binding.
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        from: None,
+                        ..
+                    } => {
+                        for spec in specifiers {
+                            if let ImportSpecifier::Named { name, alias, .. } = spec {
+                                let export_name =
+                                    alias.as_deref().unwrap_or(name.as_ref()).to_string();
+                                module_exports[idx].insert(export_name, name.to_string());
+                            }
+                        }
+                    }
                 }
             }
         }

package/crates/tish_core/src/json.rs

@@ -224,7 +224,11 @@ fn json_stringify_into_guarded(buf: &mut String, value: &Value, ancestors: &mut
 /// to `buf`. Optimised for the common case where the input is ASCII and
 /// contains no characters that need escaping — we fast-pass the bytes
 /// straight through, only falling into the per-char path on a hit.
-fn escape_json_string_into(buf: &mut String, s: &str) {
+/// Append `s` to `buf` as a JSON string body (WITHOUT the surrounding quotes), escaping `"`, `\`,
+/// and every control char < 0x20 (`\n \r \t \b \f`, else `\u00xx`). The single source of truth for
+/// JSON string escaping, shared by the vm/native path here and the interpreter's `JSON.stringify`
+/// (which otherwise hand-rolled an escaper that missed `\b`/`\f`/`\u00xx` and emitted invalid JSON).
+pub fn escape_json_string_into(buf: &mut String, s: &str) {
     let bytes = s.as_bytes();
     let mut start = 0usize;
     for (i, &b) in bytes.iter().enumerate() {

package/crates/tish_core/src/lib.rs

@@ -12,9 +12,11 @@ mod value;
 mod vmref;
 
 pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
-pub use json::{json_parse, json_stringify, json_stringify_into, write_json_number};
+pub use json::{
+    escape_json_string_into, json_parse, json_stringify, json_stringify_into, write_json_number,
+};
 pub use shape::{ShapeId, DICT_SHAPE, EMPTY_SHAPE};
-pub use uri::{percent_decode, percent_encode};
+pub use uri::{percent_decode, percent_decode_component, percent_encode, percent_encode_component};
 pub use arcstr::ArcStr;
 pub use value::*;
 pub use vmref::{VmReadGuard, VmRef, VmWriteGuard};
@@ -171,6 +173,50 @@ pub fn not_a_function_error(message: impl Into<String>) -> Value {
     Value::object(e)
 }
 
+/// A catchable `TypeError` with an arbitrary message (`{ name: "TypeError", message }`), matching the
+/// VM/interpreter/node shape. Used to PARK a pending throw from a shared builtin that returns a plain
+/// `Value` and so cannot signal an error with `Result` (e.g. `[].reduce(fn)` with no initial value).
+pub fn type_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 string key names a canonical array index iff it is a non-negative integer whose decimal form
+/// round-trips and is below the array-index ceiling (`2³²−1`): `"0"`, `"12"` → `Some`; `"01"`, `"-1"`,
+/// `"1.5"`, `"foo"`, `" 1"`, `""` → `None`. Shared so `arr["0"] === arr[0]` on every backend (#432).
+pub fn str_to_array_index(s: &str) -> Option<usize> {
+    let i: usize = s.parse().ok()?;
+    if i < 4_294_967_295 && i.to_string() == s {
+        Some(i)
+    } else {
+        None
+    }
+}
+
+/// A catchable `RangeError` with an arbitrary message (`{ name: "RangeError", message }`), matching the
+/// VM/interpreter/node shape. Used to PARK a pending throw from a shared builtin that returns a plain
+/// `Value` (e.g. `[1,2].with(5, x)` with an out-of-range index).
+pub fn range_error(message: impl Into<String>) -> 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(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

package/crates/tish_core/src/uri.rs

@@ -88,6 +88,51 @@ pub fn percent_encode(input: &str) -> String {
     result
 }
 
+/// Percent-DECODE for `decodeURIComponent` — decodes EVERY `%XX` (unlike `percent_decode`/`decodeURI`,
+/// which preserves the reserved delimiters). Bytes are collected then UTF-8 decoded, so multi-byte
+/// escapes (`%E2%82%AC` → `€`) round-trip. Errors on a malformed `%` sequence (JS `URIError`).
+pub fn percent_decode_component(input: &str) -> Result<String, String> {
+    let bytes = input.as_bytes();
+    let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'%' {
+            if i + 2 < bytes.len() {
+                if let Some(b) = std::str::from_utf8(&bytes[i + 1..i + 3])
+                    .ok()
+                    .and_then(|s| u8::from_str_radix(s, 16).ok())
+                {
+                    out.push(b);
+                    i += 3;
+                    continue;
+                }
+            }
+            return Err("URIError: malformed URI sequence".to_string());
+        }
+        out.push(bytes[i]);
+        i += 1;
+    }
+    String::from_utf8(out).map_err(|_| "URIError: malformed URI sequence".to_string())
+}
+
+/// Percent-encode for `encodeURIComponent` — escapes everything except the unreserved set
+/// `A-Za-z0-9 - _ . ! ~ * ' ( )` (stricter than `encodeURI`, which also preserves the URI reserved
+/// delimiters `; / ? : @ & = + $ , #`).
+pub fn percent_encode_component(input: &str) -> String {
+    const UNRESERVED: &[char] = &['-', '_', '.', '!', '~', '*', '\'', '(', ')'];
+    let mut result = String::with_capacity(input.len());
+    for c in input.chars() {
+        if c.is_ascii_alphanumeric() || UNRESERVED.contains(&c) {
+            result.push(c);
+        } else {
+            for byte in c.to_string().as_bytes() {
+                result.push_str(&format!("%{:02X}", byte));
+            }
+        }
+    }
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;