fix(bit_machine): use cursor position instead of frame start for tracker read iterator

The tracker was receiving a bit iterator anchored at the frame's start rather
than the current cursor position. When a `case` node executes inside another
`case` or `drop`, the read frame cursor has already advanced past the start, so
the tracker read stale bits and recorded the wrong branch. This caused
`assertl`/`assertr` pruning to remove the wrong branch after execution.

Adds a regression test covering the specific `comp (pair (injl (injr unit)) unit) (case (case unit unit) unit)` pattern that triggered the bug.

Author: stringhandler

src/bit_machine/frame.rs

@@ -123,6 +123,14 @@ impl Frame {
     ) -> BitIter<core::iter::Copied<core::slice::Iter<'a, u8>>> {
         BitIter::byte_slice_window(data, self.start, self.start + self.len)
     }
+
+    /// Like [`as_bit_iter`] but starts from the current cursor position rather than the frame start.
+    pub(super) fn as_bit_iter_from_cursor<'a>(
+        &self,
+        data: &'a [u8],
+    ) -> BitIter<core::iter::Copied<core::slice::Iter<'a, u8>>> {
+        BitIter::byte_slice_window(data, self.cursor, self.start + self.len)
+    }
 }
 
 fn get_indices(cursor: usize) -> (usize, usize) {

src/bit_machine/mod.rs

@@ -386,7 +386,7 @@ impl BitMachine {
                 // describes the Bit Machine "input" to the current node,
                 // no matter the node.
                 let read_iter = input_frame
-                    .map(|frame| frame.as_bit_iter(&self.data))
+                    .map(|frame| frame.as_bit_iter_from_cursor(&self.data))
                     .unwrap_or(crate::BitIter::from([].iter().copied()));
                 // See the docs on `tracker::NodeOutput` for more information about
                 // this match.
@@ -658,6 +658,37 @@ mod tests {
             .exec(&prog, &env)
     }
 
+    #[test]
+    #[cfg(feature = "human_encoding")]
+    fn set_tracker_cursor_regression() {
+        // When a `case` node executes inside another `case` or `drop`, the read frame cursor
+        // is no longer at the frame's start. Before this fix, `exec_with_tracker` passed an
+        // iterator starting at frame.start to the tracker, so `SetTracker` read the wrong bit
+        // and recorded the wrong branch, leading to an assertl/assertr mismatch after pruning.
+        //
+        // Program: comp (pair (injl (injr unit)) unit) (case (case unit unit) unit)
+        // Intermediate frame bits: [0=L-tag of outer, 1=R-tag of inner]
+        // Outer case: peek bit 0 = 0 (LEFT), fwd(1), cursor moves to bit 1.
+        // Inner case: should read bit 1 = 1 (RIGHT).
+        // Bug: tracker received iterator from bit 0, read 0 (LEFT) → pruned wrong branch.
+        use crate::human_encoding::Forest;
+        use crate::types;
+        use std::collections::HashMap;
+
+        types::Context::with_context(|ctx| {
+            let s = "main := comp (pair (injl (injr unit)) unit) (case (case unit unit) unit)";
+            let program = Forest::<crate::jet::Core>::parse(s)
+                .expect("parse")
+                .to_witness_node(&ctx, &HashMap::new())
+                .expect("main root")
+                .finalize_pruned(&CoreEnv::new())
+                .expect("finalize and prune");
+            let mut mac = BitMachine::for_program(&program).expect("for_program");
+            mac.exec(&program, &CoreEnv::new())
+                .expect("pruned execution should succeed");
+        });
+    }
+
     #[test]
     #[cfg(feature = "elements")]
     fn crash_regression1() {