test(reg-vm): fix stale scalar-param test + add deterministic elision regression guard

Two fixes, both test-only (+ a cfg(test) helper):

1. FIX RED LIB TEST introduced by the elision default-flip (9d38eba):
   `lowering_omits_deep_copy_for_scalar_params_only` asserted a read heap param
   retains a raw `RegInstr::DeepCopy`, but with elision default-ON the lowerer
   neutralizes it to `DeepCopyElided`, so the assertion failed. (It was masked on
   the warm main tree by a stale test binary — the known docker cargo clock-skew;
   a fresh worktree build is red.) The test's intent is scalar-vs-heap (heap params
   carry a copy-isolation marker, scalars don't), so it now accepts either
   `DeepCopy | DeepCopyElided` — flag-agnostic, intent preserved.

2. ADD regression guard for the elision win (deterministic, timing-free):
   `deepcopy_elision_fires_for_read_only_heap_param` lowers a read-only-heap-param
   program and asserts the prologue `DeepCopy` is neutralized to `DeepCopyElided`
   under the default; under RSS_VM_ELIDE_DEEPCOPY=0 it asserts the eager copy is
   retained. If a future change stops the elision from firing, `DeepCopyElided`
   disappears and a raw `DeepCopy` returns → this fails. Chosen over a perf-gate
   case because jit_perf_gate measures only the NATIVE metric; this win is
   interpreter-side, so timing there wouldn't protect it. Adds
   `elide_deepcopy_enabled_for_test()` (cfg(test)) so the test tracks the real gate.

Verified in a FRESH worktree (avoids the stale-binary trap): lib 277/0, main 41/0,
runtime 455/0, differential 33/0, cost-model 1/0, soak 7/0, static 627/0.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/reg_vm/model.rs

@@ -1852,6 +1852,14 @@ fn elide_deepcopy_enabled() -> bool {
     })
 }
 
+/// Test-only view of the process-once elision gate, so the elision regression guard
+/// (`deepcopy_elision_fires_for_read_only_heap_param`) can branch on the exact verdict
+/// the lowerer used rather than re-reading the env (and matching the memoized value).
+#[cfg(test)]
+pub(crate) fn elide_deepcopy_enabled_for_test() -> bool {
+    elide_deepcopy_enabled()
+}
+
 /// The register mutated IN PLACE by an in-scope container mutator, if any — a NON-`native-jit`
 /// mirror of `native::passes::native_heap_mutation_receiver` (which is `cfg`-gated). Mutating
 /// one of these on a tainted receiver would write through the shared `Rc` the interpreter would

crates/rsscript/src/reg_vm/tests.rs

@@ -546,12 +546,19 @@ fn main() -> Unit {
 
         let list_len_id = executable.unit.function_ids["list_len"];
         let list_len = executable.unit.functions[list_len_id].as_ref();
-        assert!(
-            list_len
-                .code
-                .iter()
-                .any(|instr| matches!(instr, RegInstr::DeepCopy { .. })),
-            "read heap/value params must retain copy isolation: {:#?}",
+        // A `read` heap/value param always carries a prologue copy-isolation MARKER in
+        // its slot: an eager `DeepCopy` when elision is off, or a neutralized
+        // `DeepCopyElided` when the compile-time elision pass (default ON) proves the
+        // copy redundant. Either way the slot is present (scalars emit neither) — this
+        // is the scalar-vs-heap distinction the test guards, independent of the elision
+        // flag. The elision-specific assertion lives in
+        // `deepcopy_elision_fires_for_read_only_heap_param`.
+        assert!(
+            list_len.code.iter().any(|instr| matches!(
+                instr,
+                RegInstr::DeepCopy { .. } | RegInstr::DeepCopyElided { .. }
+            )),
+            "read heap/value params must carry a copy-isolation marker: {:#?}",
             list_len.code,
         );
         let output = executable
@@ -560,6 +567,97 @@ fn main() -> Unit {
         assert_eq!(output.stdout, "43\n");
     }
 
+    /// Regression guard for the compile-time `DeepCopy`-elision perf win (the ~16x
+    /// speedup on `benchmarks/vm-jit/kernels/deepcopy_read_param.rss`). Mirrors that
+    /// kernel's hot shape: a NON-`mut` heap param (`g: read Bag`) used only through
+    /// read paths (`GetField` on `g`, then `List.len`/`List.get`), called from another
+    /// function. Under the DEFAULT (`RSS_VM_ELIDE_DEEPCOPY` unset ⇒ elision ON) the
+    /// lowerer must PROVE the prologue `DeepCopy` of `g` redundant and neutralize it to
+    /// `RegInstr::DeepCopyElided` — the marker that turns the per-call deep copy into a
+    /// cheap `Rc` share. If a future change re-introduces the eager copy (elision stops
+    /// firing) `DeepCopyElided` disappears and a raw `DeepCopy` returns, failing this
+    /// test. Run with `RSS_VM_ELIDE_DEEPCOPY=0` to see the guarded regression: the
+    /// elided marker is gone and the eager `DeepCopy` is back.
+    #[test]
+    fn deepcopy_elision_fires_for_read_only_heap_param() {
+        let source = r#"
+features: local
+
+struct Bag {
+    a: List<Int>,
+    b: List<Int>,
+}
+
+fn sum_reads(g: read Bag, i: Int) -> Int {
+    let na = List.len<Int>(list: read g.a)
+    let nb = List.len<Int>(list: read g.b)
+    let va = List.get<Int>(list: read g.a, index: i % na)
+    let vb = List.get<Int>(list: read g.b, index: i % nb)
+    return va + vb
+}
+
+fn caller(g: read Bag) -> Int {
+    return sum_reads(g: read g, i: 0)
+}
+
+fn main() -> Unit {
+    local a = List.new<Int>()
+    List.push<Int>(list: mut a, value: read 7)
+    local b = List.new<Int>()
+    List.push<Int>(list: mut b, value: read 5)
+    let bag = Bag(a: take a, b: take b)
+    Log.write(message: read String.from_int(value: caller(g: read bag)))
+    return Unit
+}
+"#;
+        let executable = reg_vm_compile_source("deepcopy-elision.rss", source)
+            .expect("lowering should succeed");
+
+        let sum_reads_id = executable.unit.function_ids["sum_reads"];
+        let sum_reads = executable.unit.functions[sum_reads_id].as_ref();
+        let elided = sum_reads
+            .code
+            .iter()
+            .filter(|instr| matches!(instr, RegInstr::DeepCopyElided { .. }))
+            .count();
+        let eager = sum_reads
+            .code
+            .iter()
+            .filter(|instr| matches!(instr, RegInstr::DeepCopy { .. }))
+            .count();
+        // Under the default the read-only heap param's copy is elided; the elision is
+        // gated (`elide_deepcopy_enabled`) so an explicit `RSS_VM_ELIDE_DEEPCOPY=0`
+        // process would instead leave the eager `DeepCopy` — which is exactly the
+        // regression this guard is meant to catch.
+        if crate::reg_vm::model::elide_deepcopy_enabled_for_test() {
+            assert!(
+                elided >= 1,
+                "elision ON: read-only heap param DeepCopy should be neutralized to \
+                 DeepCopyElided, got {elided} elided / {eager} eager: {:#?}",
+                sum_reads.code,
+            );
+            assert_eq!(
+                eager, 0,
+                "elision ON: no eager DeepCopy should remain for the read-only heap \
+                 param: {:#?}",
+                sum_reads.code,
+            );
+        } else {
+            assert!(
+                eager >= 1 && elided == 0,
+                "elision OFF: eager DeepCopy must be retained (perf-win regression path): \
+                 got {elided} elided / {eager} eager: {:#?}",
+                sum_reads.code,
+            );
+        }
+
+        // Elision (or its absence) must never change observable behavior.
+        let output = executable
+            .eval_main_with_args(Vec::<String>::new())
+            .expect("program should still run");
+        assert_eq!(output.stdout, "12\n");
+    }
+
     #[test]
     fn jit_runs_scalar_self_recursion_on_flat_executor() {
         let source = r#"