@tishlang/tish-format 3.10.4 → 3.10.11

package/crates/tish/src/cargo_native_registry.rs

@@ -15,6 +15,10 @@ pub(crate) fn register_bytecode_native_modules(vm: &mut tishlang_vm::Vm) {
     );
     om.insert(Arc::from("connect"), Value::native(tishlang_pg::connect));
     om.insert(Arc::from("prepare"), Value::native(tishlang_pg::prepare));
+    om.insert(
+        Arc::from("unprepare"),
+        Value::native(tishlang_pg::unprepare),
+    );
     om.insert(
         Arc::from("query_prepared"),
         Value::native(tishlang_pg::query_prepared),

package/crates/tish/src/main.rs

@@ -57,13 +57,17 @@ fn vm_capabilities_for_cli_run(cli_features: &[String]) -> HashSet<String> {
 /// `--feature` list for `tish build --target native`: same default as `tish run` (all linked-in caps).
 fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
     let mut v: Vec<String> = if cli_features.is_empty() {
-        tishlang_vm::all_compiled_capabilities().into_iter().collect()
+        tishlang_vm::all_compiled_capabilities()
+            .into_iter()
+            .collect()
     } else {
         // Normalize exactly like `tish run`: split comma-separated values (`--feature http,timers`)
         // and expand `full`. Without this, a value like "http,timers,process" was treated as one
         // opaque feature name, so `has_feature("http")` was false and the http runtime imports were
         // never emitted — async `fetch` then failed to compile (issue #209).
-        normalize_capability_flags(cli_features).into_iter().collect()
+        normalize_capability_flags(cli_features)
+            .into_iter()
+            .collect()
     };
     v.sort();
     v
@@ -73,8 +77,15 @@ fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
 fn argv_with_implicit_run(mut argv: Vec<String>) -> Vec<String> {
     if argv.len() >= 2 {
         let first = argv[1].as_str();
-        const SUBCOMMANDS: &[&str] =
-            &["run", "repl", "test", "build", "compile-module", "resolve-id", "dump-ast"];
+        const SUBCOMMANDS: &[&str] = &[
+            "run",
+            "repl",
+            "test",
+            "build",
+            "compile-module",
+            "resolve-id",
+            "dump-ast",
+        ];
         let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.contains(&first);
         if looks_like_file {
             argv.insert(1, "run".to_string());
@@ -112,19 +123,26 @@ fn main() {
             // Expose a node-shaped `process.argv` to the script: `[tish-exe, <file>, args...]`,
             // so `tish run main.tish a b` gives the script `["…/tish", "main.tish", "a", "b"]`
             // (not the `run` subcommand). Interp/VM read this via `tishlang_core::process_argv`. #88
-            let exe = std::env::args().next().unwrap_or_else(|| "tish".to_string());
+            let exe = std::env::args()
+                .next()
+                .unwrap_or_else(|| "tish".to_string());
             let mut argv = Vec::with_capacity(a.script_args.len() + 2);
             argv.push(exe);
             argv.push(a.file.clone());
             argv.extend(a.script_args.iter().cloned());
             tishlang_core::set_process_argv(argv);
-            run_file(&a.file, &a.backend, &a.features, a.no_optimize || no_opt_env)
+            run_file(
+                &a.file,
+                &a.backend,
+                &a.features,
+                a.no_optimize || no_opt_env,
+            )
         }
         Some(Commands::Test(a)) => {
             #[cfg(feature = "test-runner")]
             {
-                use tishlang_test::{run_tests, TestOptions};
                 use tishlang_test::report::ReporterKind;
+                use tishlang_test::{run_tests, TestOptions};
 
                 let reporter = match a.reporter.as_str() {
                     "dots" => ReporterKind::Dots,
@@ -169,7 +187,9 @@ fn main() {
                     } else {
                         "`--backend native` is not implemented yet"
                     };
-                    eprintln!("error: unsupported --backend `{backend}` for tish test (use `vm`); {hint}");
+                    eprintln!(
+                        "error: unsupported --backend `{backend}` for tish test (use `vm`); {hint}"
+                    );
                     std::process::exit(2);
                 }
                 let opts = TestOptions {
@@ -219,10 +239,9 @@ fn main() {
             if let Some(mode) = &a.check {
                 std::env::set_var("TISH_CHECK", mode);
             }
-            if let Err(e) = tishlang_compile::apply_resolve_env(
-                a.platform.as_deref(),
-                a.surface.as_deref(),
-            ) {
+            if let Err(e) =
+                tishlang_compile::apply_resolve_env(a.platform.as_deref(), a.surface.as_deref())
+            {
                 eprintln!("Error: {}", e);
                 std::process::exit(1);
             }
@@ -241,10 +260,9 @@ fn main() {
             )
         }
         Some(Commands::CompileModule(a)) => {
-            if let Err(e) = tishlang_compile::apply_resolve_env(
-                a.platform.as_deref(),
-                a.surface.as_deref(),
-            ) {
+            if let Err(e) =
+                tishlang_compile::apply_resolve_env(a.platform.as_deref(), a.surface.as_deref())
+            {
                 eprintln!("Error: {}", e);
                 std::process::exit(1);
             }
@@ -371,7 +389,14 @@ fn run_file(
         .parent()
         .map(|p| p.to_path_buf())
         .unwrap_or_else(|| std::path::PathBuf::from("."));
-    run_program(&program, &ffi_base, backend, no_optimize, features, Some(path))
+    run_program(
+        &program,
+        &ffi_base,
+        backend,
+        no_optimize,
+        features,
+        Some(path),
+    )
 }
 
 /// Load every `ffi:<path>` cdylib the program imports, resolving each path relative to `base_dir`
@@ -382,6 +407,8 @@ fn load_ffi_modules(
     base_dir: &Path,
 ) -> Result<Vec<(String, tishlang_core::ObjectMap)>, String> {
     let mut out = Vec::new();
+    // `ffi_native_specs` yields each spec once (deduplicated in first-seen order); distinct
+    // spellings of the same library collapse inside `load_module`'s resolved-path cache (#711).
     for spec in tishlang_compile::ffi_native_specs(program) {
         let rel = spec.strip_prefix("ffi:").unwrap_or(spec.as_str());
         let lib_path = base_dir.join(rel);
@@ -804,17 +831,27 @@ fn compile_to_js_esm(
                 .into(),
         );
     }
-    let modules =
-        tishlang_compile_js::compile_project_esm(input_path, project_root, optimize, jsx_import_source)
-            .map_err(|e| format!("{}", e))?;
+    let modules = tishlang_compile_js::compile_project_esm(
+        input_path,
+        project_root,
+        optimize,
+        jsx_import_source,
+    )
+    .map_err(|e| format!("{}", e))?;
     let out_dir = Path::new(output_path);
-    fs::create_dir_all(out_dir)
-        .map_err(|e| format!("Cannot create output directory {}: {}", out_dir.display(), e))?;
+    fs::create_dir_all(out_dir).map_err(|e| {
+        format!(
+            "Cannot create output directory {}: {}",
+            out_dir.display(),
+            e
+        )
+    })?;
     for module in &modules {
         let out = out_dir.join(&module.relative_path);
         if let Some(parent) = out.parent() {
-            fs::create_dir_all(parent)
-                .map_err(|e| format!("Cannot create output directory {}: {}", parent.display(), e))?;
+            fs::create_dir_all(parent).map_err(|e| {
+                format!("Cannot create output directory {}: {}", parent.display(), e)
+            })?;
         }
         fs::write(&out, &module.js)
             .map_err(|e| format!("Cannot write {}: {}", out.display(), e))?;
@@ -1195,7 +1232,10 @@ mod cli_tests {
         // `full` expands to every capability, matching `tish run`.
         let full = native_build_features_from_cli(&["full".to_string()]);
         for cap in ["http", "timers", "fs", "process", "regex", "ws", "tty"] {
-            assert!(full.iter().any(|s| s == cap), "`full` missing `{cap}` in {full:?}");
+            assert!(
+                full.iter().any(|s| s == cap),
+                "`full` missing `{cap}` in {full:?}"
+            );
         }
     }
 

package/crates/tish/tests/integration_test.rs

@@ -1068,6 +1068,9 @@ allSettled[1] rejected: boom
 allSettled[2] ok: 30
 race winner: A
 any passthrough: 42
+race pending-loser winner: fast
+loser still awaitable: late
+re-await: 7 7
 ";
     for backend_args in [vec!["run"], vec!["run", "--backend", "interp"]] {
         let mut args = backend_args.clone();

package/crates/tish_builtins/src/globals.rs

@@ -436,9 +436,9 @@ pub fn object_assign(args: &[Value]) -> Value {
         };
         if let Value::Object(src) = source {
             let src_borrow = src.borrow();
-            for (k, v) in src_borrow.strings.iter() {
-                target_mut.strings.insert(Arc::clone(k), v.clone());
-            }
+            // merge_from propagates dictionary-ness: copying from a DICT_SHAPE source (whose
+            // stored key order is not meaningful) must not re-mint tracked shape chains (#708).
+            target_mut.strings.merge_from(&src_borrow.strings);
             if let Some(ss) = &src_borrow.symbols {
                 if target_mut.symbols.is_none() {
                     target_mut.symbols = Some(Default::default());

package/crates/tish_builtins/src/symbol.rs

@@ -2,7 +2,14 @@
 
 #[cfg(feature = "portable")]
 #[allow(unused_imports)]
-use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+use alloc::{
+    borrow::ToOwned,
+    boxed::Box,
+    format,
+    string::{String, ToString},
+    vec,
+    vec::Vec,
+};
 
 use tishlang_core::sync::{Mutex, OnceLock};
 use tishlang_core::{alloc_symbol_id, AHashMap, Arc, ObjectMap, TishSymbol, Value};
@@ -33,7 +40,9 @@ fn symbol_new(args: &[Value]) -> Value {
         if matches!(v, Value::Null) {
             None
         } else {
-            Some(v.to_display_string().into())
+            // ECMAScript ToString of the description (`Symbol({})` → "[object Object]"), not the
+            // console-inspect form (#715). Conformance-only here: unique symbols are refcounted.
+            Some(v.to_js_string().into())
         }
     });
     Value::Symbol(TishSymbol::new_unique(desc))
@@ -54,10 +63,16 @@ fn symbol_key_for_impl(args: &[Value]) -> Value {
 pub fn symbol_object() -> Value {
     let call = Value::native(symbol_new);
     let for_fn = Value::native(|args: &[Value]| {
+        // The registry key is the ECMAScript ToString of the argument (spec: `Symbol.for`
+        // coerces with ToString), NOT the console-inspect form (#715): every object keys the
+        // single "[object Object]" entry and an array keys its comma-joined form, exactly as
+        // in JS. The inspect form turned the immortal registry's program-text-bounded key set
+        // into a data-driven one — `Symbol.for({id: n})` interned one permanent entry per
+        // distinct rendered object. A missing argument keys "undefined" (ToString(undefined)).
         let key = args
             .first()
-            .map(|v| v.to_display_string())
-            .unwrap_or_default();
+            .map(|v| v.to_js_string())
+            .unwrap_or_else(|| "undefined".to_string());
         symbol_for_impl(&key)
     });
     let key_for = Value::native(symbol_key_for_impl);
@@ -80,4 +95,71 @@ mod tests {
         let r = value_call(&o, &[Value::String("hi".into())]);
         assert!(matches!(r, Value::Symbol(_)));
     }
+
+    fn member(o: &Value, name: &str) -> Value {
+        match o {
+            Value::Object(obj) => obj
+                .borrow()
+                .strings
+                .get(name)
+                .cloned()
+                .unwrap_or_else(|| panic!("missing member {name}")),
+            other => panic!("expected object, got {other:?}"),
+        }
+    }
+
+    fn as_symbol(v: Value) -> Arc<TishSymbol> {
+        match v {
+            Value::Symbol(s) => s,
+            other => panic!("expected symbol, got {other:?}"),
+        }
+    }
+
+    fn test_object(n: f64) -> Value {
+        let mut m = ObjectMap::default();
+        m.insert(Arc::from("id"), Value::Number(n));
+        Value::object(m)
+    }
+
+    // #715: the registry keys on ToString, so two DISTINCT objects intern the SAME entry
+    // ("[object Object]") — previously each distinct inspect string ("{id: 1}", "{id: 2}", …)
+    // interned one immortal registry entry per call.
+    #[test]
+    fn symbol_for_keys_objects_by_tostring() {
+        let for_fn = member(&symbol_object(), "for");
+        let a = as_symbol(value_call(&for_fn, &[test_object(1.0)]));
+        let b = as_symbol(value_call(&for_fn, &[test_object(2.0)]));
+        assert!(
+            Arc::ptr_eq(&a, &b),
+            "distinct objects must intern one shared '[object Object]' registry entry"
+        );
+        assert_eq!(a.registry_key.as_deref(), Some("[object Object]"));
+    }
+
+    // String and number args keep their (spec-shaped) keys; ToString makes Symbol.for(1) and
+    // Symbol.for("1") the same symbol, as in JS.
+    #[test]
+    fn symbol_for_string_and_number_keys_unchanged() {
+        let for_fn = member(&symbol_object(), "for");
+        let s1 = as_symbol(value_call(&for_fn, &[Value::String("sym.key.715".into())]));
+        let s2 = as_symbol(value_call(&for_fn, &[Value::String("sym.key.715".into())]));
+        assert!(Arc::ptr_eq(&s1, &s2));
+        assert_eq!(s1.registry_key.as_deref(), Some("sym.key.715"));
+
+        let n = as_symbol(value_call(&for_fn, &[Value::Number(1.0)]));
+        let n_str = as_symbol(value_call(&for_fn, &[Value::String("1".into())]));
+        assert_eq!(n.registry_key.as_deref(), Some("1"));
+        assert!(
+            Arc::ptr_eq(&n, &n_str),
+            "Symbol.for(1) === Symbol.for(\"1\")"
+        );
+    }
+
+    // A missing argument keys "undefined" (ToString(undefined)), not "".
+    #[test]
+    fn symbol_for_missing_arg_keys_undefined() {
+        let for_fn = member(&symbol_object(), "for");
+        let s = as_symbol(value_call(&for_fn, &[]));
+        assert_eq!(s.registry_key.as_deref(), Some("undefined"));
+    }
 }

package/crates/tish_bytecode/src/compiler.rs

@@ -844,8 +844,11 @@ impl SlotScan {
 
 /// Capture-aware eligibility for general slot-based locals in a FUNCTION. Returns the captured-name set
 /// (names that must stay name-based) when eligible, else `None` (compile name-based). Eligible iff the
-/// flag is on, no rest param, all params simple, the body fully analysable, and no PARAM is captured
-/// (the VM binds params into slots 0..n, but a closure reads captures by name from `local_scope`).
+/// flag is on, no rest param, all params simple, and the body fully analysable. A CAPTURED param does
+/// NOT disqualify the chunk (#716 follow-up): the VM still binds the arg into its positional slot, and
+/// a copy-in prologue moves it into `local_scope` at entry — from then on the scope is that param's
+/// single source of truth (its name stays out of the slot map, so every body read/write compiles
+/// name-based to the very map closures capture — shared-cell mutation semantics preserved exactly).
 fn slot_analyze(
     params: &[FunParam],
     has_rest: bool,
@@ -863,13 +866,6 @@ fn slot_analyze(
     if !scan.stmt(body, false) {
         return None;
     }
-    for p in params {
-        if let FunParam::Simple(tp) = p {
-            if scan.captured.contains(&tp.name) {
-                return None;
-            }
-        }
-    }
     Some(scan.captured)
 }
 
@@ -1060,12 +1056,12 @@ impl<'a> Compiler<'a> {
             self.emit_u16(Opcode::ArgMissing, i as u16);
             let skip = self.emit_jump(Opcode::JumpIfFalse);
             self.compile_expr(default_expr)?;
-            let slot = self
-                .slot_ctx
-                .as_ref()
-                .and_then(|m| m.get(tp.name.as_ref()))
-                .copied();
-            match slot {
+            // #727: resolve through BOTH slot maps (`resolve_slot`), not `slot_ctx` alone. In
+            // GENERAL slot mode params live in `slot_scopes` (declared before this prologue) and
+            // every read of the param lowers to `LoadLocal <slot>` — a `DeclareVarPlain` here wrote
+            // the default into the name-based scope map no read resolves to, leaving the slot's
+            // missing-arg `Null` visible (`f(a, b = 5); f(1)` → `1 + null` → NaN).
+            match self.resolve_slot(tp.name.as_ref()) {
                 Some(slot) => self.emit_u16(Opcode::StoreLocal, slot),
                 None => {
                     let idx = self.name_idx(&tp.name);
@@ -2022,14 +2018,42 @@ impl<'a> Compiler<'a> {
                     inner_comp.emit_param_defaults_prologue(params)?;
                     inner_comp.compile_fn_body(body)?;
                 } else if let Some(cap) = captured {
-                    // Params (all uncaptured — gated) → slots 0..n (matching the VM's param binding);
-                    // uncaptured body `let`s get fresh slots via the scope-aware allocator; captured
-                    // locals stay name-based in `local_scope` (which closures capture).
+                    // Params → slots 0..n (matching the VM's positional arg binding); uncaptured
+                    // body `let`s get fresh slots via the scope-aware allocator; captured locals
+                    // stay name-based in `local_scope` (which closures capture).
+                    //
+                    // #716 follow-up: a CAPTURED param no longer disqualifies the chunk. It keeps
+                    // its slot NUMBER (the VM binds args positionally, so numbering must stay
+                    // 0..n) but is NOT slot-resolvable: its name never enters `slot_scopes`, so
+                    // every body read/write compiles name-based (`LoadVar`/`StoreVar`) against
+                    // `local_scope` — the very map closures capture — keeping the scope the
+                    // single source of truth (shared-cell mutation semantics preserved exactly;
+                    // a body reassignment is visible to the closure and vice versa). The COPY-IN
+                    // prologue below moves each captured arg slot → scope once at entry, BEFORE
+                    // the defaults prologue so an applied default (stored name-based for a
+                    // captured param) overwrites the copied-in missing-arg null, never the other
+                    // way around. This keeps the chunk in slot mode, so the #716 fix (#728) slot-
+                    // binds an uncaptured body-level fn NAME and the per-call frame-scope↔closure
+                    // cycle never forms for the `handleEvent(payload){ function fmt(){…payload…} }`
+                    // shape.
                     inner_comp.general_slots = true;
                     inner_comp.slot_captured = cap;
                     inner_comp.slot_scopes.push(HashMap::new());
+                    let mut captured_param_copy_ins: Vec<(u16, Arc<str>)> = Vec::new();
                     for p in &param_names {
-                        inner_comp.declare_slot(p);
+                        if inner_comp.slot_captured.contains(p.as_ref()) {
+                            // Reserve the positional slot without making it resolvable.
+                            let slot = inner_comp.next_slot;
+                            inner_comp.next_slot += 1;
+                            captured_param_copy_ins.push((slot, Arc::clone(p)));
+                        } else {
+                            inner_comp.declare_slot(p);
+                        }
+                    }
+                    for (slot, p) in &captured_param_copy_ins {
+                        inner_comp.emit_u16(Opcode::LoadLocal, *slot);
+                        let idx = inner_comp.name_idx(p);
+                        inner_comp.emit_u16(Opcode::DeclareVarPlain, idx);
                     }
                     inner_comp.emit_param_defaults_prologue(params)?;
                     inner_comp.compile_fn_body(body)?;
@@ -2056,12 +2080,28 @@ impl<'a> Compiler<'a> {
                 self.emit(Opcode::LoadConst);
                 let idx = self.constant_idx(Constant::Closure(nested_idx));
                 self.chunk.write_u16(idx);
-                let idx = self.name_idx(name);
-                self.emit_u16(Opcode::DeclareVar, idx);
-                self.scope
-                    .last_mut()
-                    .unwrap()
-                    .insert(Arc::clone(name), false);
+                // #716: bind the function's NAME like any other local. `DeclareVar` inserts the
+                // closure into the very `local_scope` map the closure just captured (vm.rs
+                // `Constant::Closure` → `VmClosure.enclosing`), minting a deterministic
+                // closure→scope→closure cycle per call — refcount-only, so the whole frame leaked.
+                // In general slot mode an UNCAPTURED name gets a frame slot instead: the closure
+                // never enters the captured map, and the frame drops normally on return. A name
+                // referenced from inside ANY nested closure — the function's own body
+                // (self-recursion) or a sibling (mutual recursion) — is in `slot_captured`
+                // (`SlotScan` scans FunDecl bodies as closures) and stays on the `DeclareVar`
+                // path, exactly like a captured `let` (see `Statement::VarDecl` above).
+                // `TISH_VM_SLOTS=0` ⇒ `general_slots` is false ⇒ byte-identical output.
+                if self.general_slots && !self.slot_captured.contains(name.as_ref()) {
+                    let slot = self.declare_slot(name);
+                    self.emit_u16(Opcode::StoreLocal, slot);
+                } else {
+                    let idx = self.name_idx(name);
+                    self.emit_u16(Opcode::DeclareVar, idx);
+                    self.scope
+                        .last_mut()
+                        .unwrap()
+                        .insert(Arc::clone(name), false);
+                }
             }
             Statement::DoWhile { body, cond, .. } => {
                 let body_lets = Self::loop_body_block_lets(body);

package/crates/tish_bytecode/tests/captured_param_slot_binding.rs

@@ -0,0 +1,131 @@
+//! #716 follow-up: a function whose PARAM is captured by a nested closure must still
+//! compile in general slot mode, with a captured-param COPY-IN PROLOGUE (`LoadLocal
+//! <param slot>` + `DeclareVarPlain <name>`) so the closure reads the param from
+//! `local_scope` while the chunk keeps frame slots for everything uncaptured —
+//! including the body-level helper NAME (#728), which is what breaks the per-call
+//! frame-scope↔closure cycle for the #716 repro shape.
+
+use tishlang_bytecode::{compile, Chunk, Opcode};
+
+/// Count occurrences of `target` in `chunk.code`, walking real instruction boundaries.
+fn count_opcode(chunk: &Chunk, target: Opcode) -> usize {
+    let code = &chunk.code;
+    let mut ip = 0usize;
+    let mut n = 0usize;
+    while ip < code.len() {
+        let op = Opcode::from_u8(code[ip]).expect("valid opcode");
+        if op == target {
+            n += 1;
+        }
+        ip += op.instruction_size(code, ip).expect("sized instruction");
+    }
+    n
+}
+
+fn compile_src(src: &str) -> Chunk {
+    let program = tishlang_parser::parse(src).expect("parse");
+    compile(&program).expect("compile")
+}
+
+/// These tests assert slot-mode emission; running the suite with `TISH_VM_SLOTS=0`
+/// deliberately exercises the legacy name-based path, where they do not apply.
+fn slots_disabled() -> bool {
+    std::env::var("TISH_VM_SLOTS")
+        .map(|v| v == "0")
+        .unwrap_or(false)
+}
+
+/// The #716 repro shape: the chunk must stay slot-based, copy the captured param in
+/// exactly once, and slot-bind the (uncaptured) helper name — zero `DeclareVar`.
+#[test]
+fn captured_param_chunk_stays_slot_based_with_copy_in() {
+    if slots_disabled() {
+        return;
+    }
+    let chunk = compile_src(
+        r#"
+function handleEvent(payload) {
+  function fmt(x) { return x + payload.tag }
+  return fmt("v")
+}
+console.log(handleEvent({ tag: "t" }))
+"#,
+    );
+    let outer = &chunk.nested[0];
+    assert!(
+        outer.slot_based,
+        "a captured-param chunk must no longer be disqualified from general slot mode"
+    );
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVarPlain),
+        1,
+        "exactly one copy-in store for the one captured param"
+    );
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVar),
+        0,
+        "the uncaptured helper name must be slot-bound (#728), not DeclareVar-bound — \
+         that is the cycle"
+    );
+    assert!(
+        count_opcode(outer, Opcode::StoreLocal) >= 1,
+        "the helper closure should be stored to a frame slot"
+    );
+}
+
+/// Mixed params: only the CAPTURED one is copied in; the uncaptured one stays
+/// slot-resolved (no name-based traffic for it).
+#[test]
+fn only_captured_params_are_copied_in() {
+    if slots_disabled() {
+        return;
+    }
+    let chunk = compile_src(
+        r#"
+function outer(p, q) {
+  function get() { return p }
+  let r = get() + q
+  return r
+}
+console.log(outer(1, 2))
+"#,
+    );
+    let outer = &chunk.nested[0];
+    assert!(outer.slot_based, "mixed-param chunk should be slot-based");
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVarPlain),
+        1,
+        "only the captured param `p` gets a copy-in store; `q` stays slotted"
+    );
+}
+
+/// A self-recursive helper capturing the param: the helper NAME is captured (its own
+/// body references it) and stays on the `DeclareVar` scope path, while the chunk itself
+/// remains slot-based with the param copy-in.
+#[test]
+fn self_recursive_helper_keeps_scope_path_beside_copy_in() {
+    if slots_disabled() {
+        return;
+    }
+    let chunk = compile_src(
+        r#"
+function outer(n) {
+  function fact(k) { if (k < 2) { return n } return k * fact(k - 1) }
+  return fact(4)
+}
+console.log(outer(1))
+"#,
+    );
+    let outer = &chunk.nested[0];
+    assert!(outer.slot_based, "chunk should stay slot-based");
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVarPlain),
+        1,
+        "the captured param `n` gets its copy-in"
+    );
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVar),
+        1,
+        "the self-recursive helper name is captured and stays DeclareVar-bound"
+    );
+}