feat(reg-vm): J0.1 enable precise resume by default

Make precise deopt resume the production default: a native guard bail now
reconstructs the live interpreter window and resumes at the safepoint instead of
re-running the function from the top. Sound since the J0.1 heap-aware
reconstruction landed (scalars restored, heap/flat regs left to the frame).

- `eval_main_with_args_native` (+ `_with_stats`): pass `precise_deopt_override =
  true`. This is what the CLI and the differential `vm-jit-native` backend use.
- re-run-from-top remains the byte-identical fallback when a heap write disables
  precise resume (`can_precise_deopt_resume`), and stays under differential
  coverage via the force-deopt backend (`eval_main_with_args_native_force_deopt`
  keeps precise=false). `RSS_JIT_PRECISE_DEOPT` still forces it on elsewhere.

Validated byte-identical corpus-wide: differential 33/0 first with
RSS_JIT_PRECISE_DEOPT=1 (proving precise resume matches every backend), then
again after the default flip; rsscript lib 276/0, jit_acceptance 83/0, default
workspace build OK.

Remaining for full J0.1: inlined logical-frame-chain state-map format, and
heap-payload-variant / live-out composite-heap-value reconstruction (rebuilding
native-built variant/struct values with heap payloads across a bail; today such
arms bail).

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

Author: olwang

crates/rsscript/src/reg_vm/mod.rs

@@ -1269,7 +1269,13 @@ impl RegVmExecutable {
             tier_up_threshold,
             false,
             std::env::var_os("RSS_JIT_STATS").is_some(),
-            false,
+            // J0.1: precise resume is the production DEFAULT. A native guard bail
+            // reconstructs the live interpreter window (heap-aware: scalars restored,
+            // heap/flat regs left to the frame) and resumes at the safepoint. It is
+            // byte-identical to re-run-from-top (validated corpus-wide), which remains
+            // the fallback when a heap write disables precise resume and is kept under
+            // differential coverage by the force-deopt backend.
+            true,
             false,
             None,
             false,
@@ -1293,7 +1299,9 @@ impl RegVmExecutable {
             tier_up_threshold,
             false,
             true,
-            false,
+            // J0.1: precise resume is the production default (see
+            // `eval_main_with_args_native`).
+            true,
             false,
             None,
             false,
@@ -1493,13 +1501,15 @@ impl RegVmExecutable {
         // compiled subset, host helpers, and deopt oracle are identical, so the
         // differential (which never sets this var) is undisturbed.
         let baseline = std::env::var_os("RSS_JIT_BASELINE").is_some();
-        // `RSS_JIT_PRECISE_DEOPT=1` (J0.2) makes a native bail resume the
-        // interpreter at the safepoint's `resume_ip` (reconstructing the live
-        // register window) instead of re-running from the function top. Default
-        // (unset) keeps the byte-identical re-run-from-top baseline, so the
-        // differential (which never sets this var) keeps full coverage. A caller
-        // may also force it on deterministically (test entry points) via
-        // `precise_deopt_override`, avoiding a racy process env var.
+        // Precise resume (J0.1/J0.2): a native bail resumes the interpreter at the
+        // safepoint's `resume_ip` (reconstructing the live register window —
+        // heap-aware: scalar regs restored, heap/flat regs left to the frame)
+        // instead of re-running from the function top. This is now the production
+        // DEFAULT (`eval_main_with_args_native` passes `precise_deopt_override`);
+        // re-run-from-top remains the byte-identical fallback when a heap write
+        // disables precise resume (`can_precise_deopt_resume`) and is kept under
+        // differential coverage by the force-deopt backend. `RSS_JIT_PRECISE_DEOPT`
+        // still forces it on for entry points that default it off.
         let precise_deopt =
             precise_deopt_override || std::env::var_os("RSS_JIT_PRECISE_DEOPT").is_some();
         // `RSS_JIT_OSR=1` (J5.2) selects the eager OSR path: a function with a

docs/planning/vm-optimizing-jit-plan.md

@@ -36,8 +36,8 @@ numeric-mode language decision). Owner: TBD. Created 2026-06-20; status updated
 
 | Item | State | Notes |
 |---|---|---|
-| **J0.0–J0.3** precise-deopt spine | **shipped (leaf/scalar subset)** | `NativeOutcome::Deopt` + per-site safepoint ids + live-reg capture + state-map + precise resume + every-safepoint stress test. **Precise resume is default-OFF** (gated by `RSS_JIT_PRECISE_DEOPT` / a test entrypoint); production still re-runs from the function top (byte-identical for the side-effect-free subset). The state-map is `resume_ip + live registers` — **not** yet the full inlined logical-frame-chain format J0.1 describes. So: done for the current leaf/scalar subset; full inlined-frame / side-effecting deopt is still **future**. |
-| **J0.1 (heap-aware reg reconstruction)** | **shipped (slice)** | The deopt state map now distinguishes reconstructible scalars (`Int`/`Float`) from heap refs (`Handle`/`FlatInt`/`FlatFloat`): `decode_deopt_live` reconstructs only scalar regs (the interpreter frame already holds heap values — precise resume implies no heap writes), and `restore_native_deopt_live_regs` restores ALL scalar regs incl. **reassigned scalar params** (the `< n_params` skip is gone). Fixes the reassigned-scalar-param resume bug (`precise_deopt_restores_reassigned_scalar_param`); flat-buffer params stay uncorrupted. **Remaining for full J0.1:** inlined logical-frame-chain state-map format, heap-payload-variant / live-out *value* reconstruction (native-built heap values across a bail), and enabling precise resume by default. |
+| **J0.0–J0.3** precise-deopt spine | **shipped (leaf/scalar subset)** | `NativeOutcome::Deopt` + per-site safepoint ids + live-reg capture + state-map + precise resume + every-safepoint stress test. **Precise resume is now the production DEFAULT** (`eval_main_with_args_native`); re-run-from-top remains the byte-identical fallback when a heap write disables precise resume (`can_precise_deopt_resume`) and stays under differential coverage via the force-deopt backend. The state-map is `resume_ip + live registers` — **not** yet the full inlined logical-frame-chain format J0.1 describes. So: done for the current leaf/scalar subset; full inlined-frame / side-effecting deopt is still **future**. |
+| **J0.1 (heap-aware reg reconstruction)** | **shipped** | The deopt state map distinguishes reconstructible scalars (`Int`/`Float`) from heap refs (`Handle`/`FlatInt`/`FlatFloat`): `decode_deopt_live` reconstructs only scalar regs (the interpreter frame already holds heap values — precise resume implies no heap writes), and `restore_native_deopt_live_regs` restores ALL scalar regs incl. **reassigned scalar params** (the `< n_params` skip is gone). Fixes the reassigned-scalar-param resume bug (`precise_deopt_restores_reassigned_scalar_param`); flat-buffer params stay uncorrupted. **Precise resume is now default-on (validated corpus-wide).** **Remaining for full J0.1:** inlined logical-frame-chain state-map format, and heap-payload-variant / live-out *value* reconstruction (rebuilding native-built composite heap values — variant/struct with heap payload — across a bail; today such arms bail). |
 | **J0.4** heap writes + deopt-after-write | **future** | blocked on native heap-write codegen; the native subset is read-only today. |
 | **J0.5** in-generated-code `VmLimits` accounting | **future** | currently the Model-A fallback (see J6); the `VmLimitsSnapshot` tick/poll machinery is not built. |
 | **J1** profiling | **shipped** | per-call-site type feedback on dynamic sites, warm-gated, no interpreter regression. (Branch profiling **not** shipped — it regressed `bool_logic_loop` ~7%; needs a hot/cold dispatch split.) |