feat(vm-jit): native-call ABI slice 1 — depth-carrying call ABI

First slice of native recursion (the call-ABI keystone). Threads a native
call-chain depth through the compiled-function ABI so a later slice can guard
against host-stack overflow before enabling recursive native->native calls.

- CompiledAbi gains a trailing `depth: usize` parameter.
- compile_inner appends it to the function signature; build_function binds it at
  the entry block.
- Each `CallNative` forwards `caller_depth + 1` to its callee; the top-level
  `call()` starts the chain at depth 0.

Carried only — no entry guard yet, so behavior is unchanged. The public
`NativeModule::call` signature is unchanged, so reg_vm callers are unaffected.

Validated: vm-jit 81/0 (incl. native-call-chain + child-deopt), differential
33/0 (the corpus heavily exercises CallNative + force-deopt), rsscript lib
native-call/deopt 15/0, jit_acceptance 83/0, default workspace build clean.

Next: slice 2 — CallSelf lowering + entry depth guard (declare-before-define).

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

Author: olwang

crates/vm-jit/src/lib.rs

@@ -1237,6 +1237,7 @@ type CompiledAbi = unsafe extern "C" fn(
     *const u8,
     *mut i64,
     *mut i64,
+    usize,
 ) -> u8;
 
 #[derive(Debug)]
@@ -1833,6 +1834,11 @@ impl NativeModule {
         self.ctx.func.signature.params.push(AbiParam::new(ptr_ty)); // bail flag ptr
         self.ctx.func.signature.params.push(AbiParam::new(ptr_ty)); // safepoint id out ptr
         self.ctx.func.signature.params.push(AbiParam::new(ptr_ty)); // deopt payload out ptr
+        // Native call depth (native-call-ABI slice 1): the dynamic depth of the
+        // native->native call chain. Threaded so a recursive native frame can bail to
+        // the interpreter before overflowing the host C stack (the guard lands in a
+        // later slice; for now it is carried only). `usize`-width == pointer-width.
+        self.ctx.func.signature.params.push(AbiParam::new(ptr_ty)); // native call depth
         self.ctx
             .func
             .signature
@@ -2169,6 +2175,9 @@ impl NativeModule {
                             bail_ptr,
                             safepoint_ptr,
                             payload_ptr,
+                            // Top-level native entry: the native call chain starts at
+                            // depth 0 (native-call-ABI slice 1).
+                            0,
                         )
                     };
                     if completed != 0 && bail.get() == 0 {
@@ -3435,6 +3444,10 @@ fn build_function(
     let bail_ptr = params[5];
     let safepoint_ptr = params[6];
     let payload_ptr = params[7];
+    // Native call depth (native-call-ABI slice 1): the chain depth passed by the
+    // caller. Forwarded as `depth + 1` to native callees so a future entry guard can
+    // bail before host-stack overflow; not yet checked.
+    let native_call_depth = params[8];
     // Running per-site bail-id counter. Starts at 1 (0 is reserved = no bail);
     // `bail_if` post-increments it so every guard/bail site gets a stable id.
     let mut next_id: i64 = 1;
@@ -3931,6 +3944,10 @@ fn build_function(
                 let safepoint_ptr_v = bcx.ins().stack_addr(ptr_ty, safepoint_slot, 0);
                 let payload_ptr_v = bcx.ins().stack_addr(ptr_ty, payload_slot, 0);
                 let nargs_v = bcx.ins().iconst(ptr_ty, meta.n_params as i64);
+                // Forward the chain depth as `caller_depth + 1` (native-call-ABI
+                // slice 1): a native callee's depth is one deeper than its caller's.
+                let one_depth = bcx.ins().iconst(ptr_ty, 1);
+                let child_depth = bcx.ins().iadd(native_call_depth, one_depth);
                 let call = bcx.ins().call(
                     native_ref(*callee),
                     &[
@@ -3942,6 +3959,7 @@ fn build_function(
                         bail_ptr_v,
                         safepoint_ptr_v,
                         payload_ptr_v,
+                        child_depth,
                     ],
                 );
                 let completed = bcx.inst_results(call)[0];

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

@@ -214,10 +214,24 @@ machinery **engage real program shapes and prove it**, not new subsystems. In pr
       investigated), `json` (1.01, parse), `string-map` (0.98, Map-key hashing). These need
       `List.len(split(...))` count-law / `starts_with` byte-compare folds, or the general allocation
       path (a) for programs that actually *use* the constructed strings; each is its own slice.
-   2. **Native-call ABI — the large architectural keystone (later).** Unlocks `recursion-tree`/
-      `fib` (~192 ms), bounded recursion generally, and non-inlinable cross-function native calls.
-      Much larger, and it will interact with the full inlined frame-chain deopt / state maps
-      (Pending #3, J0.1) and a host-stack depth guard — scope it deliberately, not opportunistically.
+   2. **Native-call ABI — the large architectural keystone (IN PROGRESS, sliced).** Unlocks
+      `recursion-tree`/`fib` (~192 ms today via the tier-0 scalar executor, not Cranelift),
+      bounded recursion generally, and non-inlinable cross-function native calls. Non-recursive
+      native call chains already ship (`CallNative` + child-frame deopt); the remaining work is
+      **native recursion**, blocked by (i) self-reference (a `CallNative` resolves its callee via
+      `self.funcs`, but a self-call's id isn't minted until compile returns → needs a self-call IR
+      form + declare-before-define), and (ii) a **host-stack depth guard** (native→native calls the
+      callee on the host C stack at lib.rs CallNative codegen, so unbounded recursion overflows it
+      → a crash, not a clean bail; safety-critical). Sliced:
+      - **Slice 1 — depth-carrying ABI: DONE.** `CompiledAbi` gained a trailing `depth: usize`
+        param; the top-level `call()` passes 0, each `CallNative` passes `caller_depth + 1`. Carried
+        only (no entry guard yet); behavior unchanged, validated by vm-jit 81/0 + differential 33/0.
+      - **Slice 2 — self-call lowering + entry depth guard** (next): a `CallSelf` IR form,
+        declare-before-define in `compile_inner`, and an entry check that bails (deopts to the
+        interpreter) when `depth >= cap` so the host stack can't overflow.
+      - **Slice 3 — enable + verify** (`fact`/`fib` go native, byte-identical to interp, deep
+        recursion bails cleanly at the cap), then **slice 4 — mutual recursion** (declare a cycle
+        before defining). Interacts with the frame-chain deopt / state maps (Pending #3, J0.1).
    *Net (FRONTIER REACHED, 2026-06-23): the cleanly-tractable incremental wins are DONE* — folds
    (string/Bytes length, ~13×/~20×), scalar replacement (Option/variant/struct/nested/loop-carried),
    closure-sink (~53×), TCO (~70×), float (~42×), deopt-before-heap (~10×), plus the registry +