fix: Preserve interior anchor after a skippable first item

When a sequence starts with a skippable quantifier (`?`/`*`) that compiles
with Down navigation, `compile_seq_items_with_skip_exit` rebuilt the remaining
items from expression indices only, dropping any `SeqItem::Anchor`. The
follower then received an unanchored nav on both the skip and match paths, so
the anchored adjacency was silently not enforced.

Slice the original `items` by position for each path so `compute_nav_modes`
sees the anchor:
- skip path (optional absent): keep the anchor as a leading anchor relative to
  the parent (DownSkip/DownExact)
- match path (optional present): start at the follower and reuse its sibling
  nav (NextSkip/NextExact)

Also detect the first skippable expression via `nav_modes` rather than
`items.first()`, so a leading anchor before the skippable doesn't hide it.

Closes #415

Author: zharinov

crates/plotnik-compiler/src/compile/sequences.rs

@@ -128,9 +128,11 @@ impl Compiler<'_> {
         // Check if first expression is skippable and uses Down navigation.
         // In this case, the skip path needs different navigation than the match path.
         // Also trigger when skip_exit is provided (for bypassing Up in parent node).
-        let first_is_skippable = items
+        // Use the first *expression* index from `nav_modes`, not `items.first()`, so a
+        // leading anchor (e.g. `{. (a)? ...}`) doesn't hide a skippable first item.
+        let first_is_skippable = nav_modes
             .first()
-            .and_then(|item| item.as_expr())
+            .and_then(|(idx, _)| items[*idx].as_expr())
             .is_some_and(is_skippable_quantifier);
         let first_uses_down = is_down_nav(first_expr_nav);
         let needs_skip_exit =
@@ -220,36 +222,45 @@ impl Compiler<'_> {
         capture: CaptureEffects,
         caller_skip_exit: Option<Label>,
     ) -> Label {
-        let first_expr = items[nav_modes[0].0]
+        let first_expr_idx = nav_modes[0].0;
+        let first_expr = items[first_expr_idx]
             .as_expr()
             .expect("first item must be expression");
 
-        // Build rest items once (shared between skip and match paths)
-        let rest_items: Vec<_> = nav_modes[1..]
-            .iter()
-            .filter_map(|(idx, _)| items.get(*idx).and_then(|i| i.as_expr()))
-            .map(|e| SeqItem::Expr(e.clone()))
-            .collect();
-
-        // Compile continuation with both navigations, or use exit if no continuation.
-        // When caller_skip_exit is provided and rest is empty, use it for skip path
-        // (this allows skip to bypass Up instruction in parent node).
-        let (skip_exit, match_exit) = if rest_items.is_empty() {
+        // Compile the continuation with both navigations, or use exit if there is none.
+        // When caller_skip_exit is provided and there is no follower, use it for the skip
+        // path (this allows skip to bypass the Up instruction in the parent node).
+        //
+        // The two paths must slice `items` differently so that any anchor between the
+        // optional first item and its follower survives into `compute_nav_modes`:
+        //
+        // - Skip path (first item absent): the anchor degrades to a leading anchor
+        //   relative to the parent. Slicing *after* the first expression keeps the
+        //   anchor, so it is re-derived as first-child (`Down*`) navigation.
+        // - Match path (first item present): the follower is the first item's sibling.
+        //   Slice *from* the follower (dropping the now-consumed leading anchor) and
+        //   reuse the sibling navigation `compute_nav_modes` already derived for it,
+        //   which carries the anchor's adjacency (`Next*`).
+        let (skip_exit, match_exit) = if nav_modes.len() < 2 {
             (caller_skip_exit.unwrap_or(exit), exit)
         } else {
+            let skip_rest = &items[first_expr_idx + 1..];
             let skip = self.compile_seq_items_inner(
-                &rest_items,
+                skip_rest,
                 exit,
                 is_inside_node,
-                first_nav, // Down variant for skip path
+                first_nav, // Down variant; overridden when a leading anchor is present
                 capture.clone(),
                 caller_skip_exit, // Propagate for nested skippables
             );
+
+            let follower_idx = nav_modes[1].0;
+            let match_rest = &items[follower_idx..];
             let mtch = self.compile_seq_items_inner(
-                &rest_items,
+                match_rest,
                 exit,
                 is_inside_node,
-                repeat_nav_for(first_nav), // Next variant for match path
+                nav_modes[1].1, // Follower's sibling nav (anchor-aware) for match path
                 capture.clone(),
                 None, // Match path doesn't need skip exit
             );

crates/plotnik-compiler/src/emit/emit_tests.rs

@@ -711,6 +711,30 @@ fn optional_first_child() {
     );
 }
 
+#[test]
+fn optional_first_child_then_interior_anchor() {
+    // Regression for #415: the interior anchor must survive into both follower
+    // compilations. The match path (optional present) gets a NextSkip (`─•─`)
+    // and the skip path (optional absent) a DownSkip (`└•─`) — both bounded, not
+    // the unanchored Next/Down (`‣`) that silently searched past named nodes.
+    shot_bytecode!(
+        r#"
+        Test = (program {(lexical_declaration)? @a . (debugger_statement) @b})
+    "#
+    );
+}
+
+#[test]
+fn optional_first_child_then_strict_interior_anchor() {
+    // As above, but the strict anchor must degrade to NextExact / DownExact on the
+    // match and skip paths respectively.
+    shot_bytecode!(
+        r#"
+        Test = (program {(lexical_declaration)? @a .! (debugger_statement) @b})
+    "#
+    );
+}
+
 #[test]
 fn optional_null_injection() {
     shot_bytecode!(

crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_first_child_then_interior_anchor.snap

@@ -0,0 +1,49 @@
+---
+source: crates/plotnik-compiler/src/emit/emit_tests.rs
+---
+Test = (program {(lexical_declaration)? @a . (debugger_statement) @b})
+---
+[strings]
+S0 "Beauty will save the world"
+S1 "a"
+S2 "b"
+S3 "Test"
+S4 "program"
+S5 "lexical_declaration"
+S6 "debugger_statement"
+
+[type_defs]
+T0 = <Node>
+T1 = Struct  M0:2  ; { a, b }
+T2 = Struct  M2:1  ; { a }
+T3 = Struct  M3:1  ; { b }
+T4 = Optional(T0)  ; <Node>?
+
+[type_members]
+M0: S1 → T4  ; a: T4
+M1: S2 → T0  ; b: <Node>
+M2: S1 → T4  ; a: T4
+M3: S2 → T0  ; b: <Node>
+
+[type_names]
+N0: S3 → T1  ; Test
+
+[entrypoints]
+Test = 06 :: T1
+
+[transitions]
+_ObjWrap:
+  00  -ε-  [Obj]                            02
+  02       Trampoline                       03
+  03  -ε-  [EndObj]                         05
+  05                                        ▶
+
+Test:
+  06   !   (program)                        18, 09
+  08                                        ▶
+  09  └•─  [Null Set(M0)] (debugger_statement) [Node Set(M1)]  20
+  12  ─•─  (debugger_statement) [Node Set(M1)]  20
+  14   !   (lexical_declaration) [Node Set(M0)]  12
+  16  ─‣─  _                                14, 16
+  18  └‣─  _                                14, 16
+  20  ─‣┘  _                                08

crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_first_child_then_strict_interior_anchor.snap

@@ -0,0 +1,49 @@
+---
+source: crates/plotnik-compiler/src/emit/emit_tests.rs
+---
+Test = (program {(lexical_declaration)? @a .! (debugger_statement) @b})
+---
+[strings]
+S0 "Beauty will save the world"
+S1 "a"
+S2 "b"
+S3 "Test"
+S4 "program"
+S5 "lexical_declaration"
+S6 "debugger_statement"
+
+[type_defs]
+T0 = <Node>
+T1 = Struct  M0:2  ; { a, b }
+T2 = Struct  M2:1  ; { a }
+T3 = Struct  M3:1  ; { b }
+T4 = Optional(T0)  ; <Node>?
+
+[type_members]
+M0: S1 → T4  ; a: T4
+M1: S2 → T0  ; b: <Node>
+M2: S1 → T4  ; a: T4
+M3: S2 → T0  ; b: <Node>
+
+[type_names]
+N0: S3 → T1  ; Test
+
+[entrypoints]
+Test = 06 :: T1
+
+[transitions]
+_ObjWrap:
+  00  -ε-  [Obj]                            02
+  02       Trampoline                       03
+  03  -ε-  [EndObj]                         05
+  05                                        ▶
+
+Test:
+  06   !   (program)                        18, 09
+  08                                        ▶
+  09  └─!  [Null Set(M0)] (debugger_statement) [Node Set(M1)]  20
+  12  ──!  (debugger_statement) [Node Set(M1)]  20
+  14   !   (lexical_declaration) [Node Set(M0)]  12
+  16  ─‣─  _                                14, 16
+  18  └‣─  _                                14, 16
+  20  ─‣┘  _                                08

docs/lang-reference.md

@@ -852,6 +852,19 @@ For strict token-level adjacency:
 
 Here, no trivia is allowed between the function name and the opening parenthesis because the anchor is explicit strict adjacency.
 
+### Anchors After Optional Items
+
+When the item before an anchor is optional (`?` or `*`), the anchor's meaning depends on whether that item matched:
+
+```
+(program {(lexical_declaration)? @a . (debugger_statement) @b})
+```
+
+- **When `@a` matches**, the anchor is enforced between the two siblings: `@b` must be the adjacent sibling, so `let x; debugger;` matches but `let x; foo; debugger;` does not.
+- **When `@a` is skipped**, the anchor degrades to a leading anchor relative to the parent — as if the query were `(program . (debugger_statement) @b)`. `@b` must be the first child (trivia aside): `debugger;` and `/* c */ debugger;` match, but `foo; debugger;` does not.
+
+Strictness carries through both paths: with `.!`, no trivia is tolerated on either the adjacency or the leading interpretation.
+
 ### Output Types
 
 Anchors are structural constraints only — they don't affect output types: