diff --git a/crates/plotnik-lib/src/bytecode/dump.rs b/crates/plotnik-lib/src/bytecode/dump.rs
index 01fec032..7d3dc0d0 100644
--- a/crates/plotnik-lib/src/bytecode/dump.rs
+++ b/crates/plotnik-lib/src/bytecode/dump.rs
@@ -45,8 +45,6 @@ struct DumpContext {
     node_type_names: BTreeMap<u16, String>,
     /// Maps node field ID to name (linked mode only).
     node_field_names: BTreeMap<u16, String>,
-    /// Entrypoint names by index (for Return formatting).
-    entrypoint_names: Vec<String>,
     /// All strings (for unlinked mode lookups).
     all_strings: Vec<String>,
 }
@@ -61,12 +59,10 @@ impl DumpContext {
         let node_fields = module.node_fields();
 
         let mut step_labels = BTreeMap::new();
-        let mut entrypoint_names = Vec::with_capacity(entrypoints.len());
         for i in 0..entrypoints.len() {
             let ep = entrypoints.get(i);
             let name = strings.get(ep.name).to_string();
-            step_labels.insert(ep.target.0, name.clone());
-            entrypoint_names.push(name);
+            step_labels.insert(ep.target.0, name);
         }
 
         let mut node_type_names = BTreeMap::new();
@@ -92,7 +88,6 @@ impl DumpContext {
             step_labels,
             node_type_names,
             node_field_names,
-            entrypoint_names,
             all_strings,
         }
     }
@@ -126,10 +121,6 @@ impl DumpContext {
             self.all_strings.get(id as usize).map(|s| s.as_str())
         }
     }
-
-    fn entrypoint_name(&self, index: usize) -> Option<&str> {
-        self.entrypoint_names.get(index).map(|s| s.as_str())
-    }
 }
 
 fn dump_strings(out: &mut String, module: &Module) {
@@ -367,6 +358,36 @@ fn instruction_step_count(instr: &Instruction) -> u16 {
     }
 }
 
+// =============================================================================
+// Instruction Line Format
+// =============================================================================
+//
+// Each instruction line follows this column layout:
+//
+//   <indent><step><gap><nav><marker><content>...<successors>
+//   ├──────┤├───┤├─┤├──┤├────┤├──────────────┤├──────────┤
+//      2     var  1   3   3       variable      pad to 44
+//
+// - indent:  2 spaces
+// - step:    step number, zero-padded to `step_width`
+// - gap:     1 space
+// - nav:     3-char navigation symbol (↓*, *↑¹, etc.) or 𝜀 for Stay
+// - marker:  3-char marker column (" ▶ " for Call, "   " otherwise)
+// - content: variable-width instruction content
+// - successors: right-aligned at column 44
+//
+// =============================================================================
+
+/// Column widths for instruction formatting.
+#[allow(dead_code)]
+mod cols {
+    pub const INDENT: usize = 2;
+    pub const GAP: usize = 1;
+    pub const NAV: usize = 3;
+    pub const MARKER: usize = 3;
+    pub const TOTAL_WIDTH: usize = 44;
+}
+
 fn format_instruction(
     step: u16,
     instr: &Instruction,
@@ -381,6 +402,33 @@ fn format_instruction(
     }
 }
 
+/// Build instruction line prefix: `  <step>  <nav>`
+///
+/// The `is_epsilon` flag controls whether to display `𝜀` for the navigation column.
+/// True epsilon transitions require all three conditions:
+/// - `nav == Stay` (no cursor movement)
+/// - `node_type == None` (no type constraint)
+/// - `node_field == None` (no field constraint)
+///
+/// A Match with `nav == Stay` but type/field constraints is NOT epsilon—it matches
+/// at the current position. Only true epsilon transitions display the `𝜀` symbol.
+fn line_prefix(step: u16, nav: Nav, is_epsilon: bool, step_width: usize) -> String {
+    let nav_str = if is_epsilon {
+        " 𝜀 ".to_string()
+    } else {
+        format_nav(nav)
+    };
+    format!(
+        "{:indent$}{:0sw$}{:gap$}{nav_str}",
+        "",
+        step,
+        "",
+        indent = cols::INDENT,
+        sw = step_width,
+        gap = cols::GAP,
+    )
+}
+
 fn format_match(
     step: u16,
     m: &Match,
@@ -388,86 +436,89 @@ fn format_match(
     ctx: &DumpContext,
     step_width: usize,
 ) -> String {
-    // Nav column: 7 chars total for content alignment
-    // 𝜀 (epsilon) centered for Stay, others left-aligned with 2-char gap
-    let nav_col = if m.nav == Nav::Stay {
-        "   𝜀   ".to_string()
-    } else {
-        let sym = format_nav(m.nav);
-        let sym_len = sym.chars().count();
-        let gap2 = 7usize.saturating_sub(2 + sym_len).max(1);
-        format!("  {sym}{:gap2$}", "")
-    };
+    let prefix = line_prefix(step, m.nav, m.is_epsilon(), step_width);
+    let marker = "   "; // No marker for Match
+
+    let content = format_match_content(m, ctx);
+    let successors = format_successors(&m.successors, ctx, step_width);
 
-    let mut content_parts = Vec::new();
+    let base = format!("{prefix}{marker}{content}");
+    pad_to_column(base, cols::TOTAL_WIDTH, &successors)
+}
+
+/// Format Match instruction content (effects, node pattern, etc.)
+fn format_match_content(m: &Match, ctx: &DumpContext) -> String {
+    let mut parts = Vec::new();
 
     // Pre-effects
     if !m.pre_effects.is_empty() {
         let effects: Vec<_> = m.pre_effects.iter().map(format_effect).collect();
-        content_parts.push(format!("[{}]", effects.join(" ")));
+        parts.push(format!("[{}]", effects.join(" ")));
     }
 
     // Negated fields
     for &field_id in &m.neg_fields {
         let name = ctx
             .node_field_name(field_id)
-            .map(|s| s.to_string())
+            .map(String::from)
             .unwrap_or_else(|| format!("field#{field_id}"));
-        content_parts.push(format!("!{name}"));
+        parts.push(format!("!{name}"));
     }
 
     // Field constraint and node type
-    let mut node_part = String::new();
+    let node_part = format_node_pattern(m, ctx);
+    if !node_part.is_empty() {
+        parts.push(node_part);
+    }
+
+    // Post-effects
+    if !m.post_effects.is_empty() {
+        let effects: Vec<_> = m.post_effects.iter().map(format_effect).collect();
+        parts.push(format!("[{}]", effects.join(" ")));
+    }
+
+    parts.join(" ")
+}
+
+/// Format node pattern: `field: (type)` or `(type)` or `field: _`
+fn format_node_pattern(m: &Match, ctx: &DumpContext) -> String {
+    let mut result = String::new();
 
     if let Some(field_id) = m.node_field {
         let name = ctx
             .node_field_name(field_id.get())
-            .map(|s| s.to_string())
+            .map(String::from)
             .unwrap_or_else(|| format!("field#{}", field_id.get()));
-        node_part.push_str(&name);
-        node_part.push_str(": ");
+        result.push_str(&name);
+        result.push_str(": ");
     }
 
     if let Some(type_id) = m.node_type {
         let name = ctx
             .node_type_name(type_id.get())
-            .map(|s| s.to_string())
+            .map(String::from)
             .unwrap_or_else(|| format!("node#{}", type_id.get()));
-        node_part.push('(');
-        node_part.push_str(&name);
-        node_part.push(')');
+        result.push('(');
+        result.push_str(&name);
+        result.push(')');
     } else if m.node_field.is_some() {
-        node_part.push('_');
+        result.push('_');
     }
 
-    if !node_part.is_empty() {
-        content_parts.push(node_part);
-    }
-
-    // Post-effects
-    if !m.post_effects.is_empty() {
-        let effects: Vec<_> = m.post_effects.iter().map(format_effect).collect();
-        content_parts.push(format!("[{}]", effects.join(" ")));
-    }
+    result
+}
 
-    // Successors
-    let succ_str = if m.successors.is_empty() {
+/// Format successors list or terminal symbol.
+fn format_successors(successors: &[StepId], ctx: &DumpContext, step_width: usize) -> String {
+    if successors.is_empty() {
         "◼".to_string()
     } else {
-        m.successors
+        successors
             .iter()
             .map(|s| format_step(*s, ctx, step_width))
             .collect::<Vec<_>>()
             .join(", ")
-    };
-
-    let content = content_parts.join(" ");
-    let base = if content.is_empty() {
-        format!("  {:0sw$}{nav_col}", step, sw = step_width)
-    } else {
-        format!("  {:0sw$}{nav_col}{content}", step, sw = step_width)
-    };
-    pad_to_column(base, 44, &succ_str)
+    }
 }
 
 fn format_call(
@@ -477,29 +528,44 @@ fn format_call(
     ctx: &DumpContext,
     step_width: usize,
 ) -> String {
+    // Call is never epsilon—it always invokes a target definition
+    let prefix = line_prefix(step, c.nav, false, step_width);
+    let marker = " ▶ "; // Call marker (centered)
+
+    // Format field constraint if present
+    let field_part = if let Some(field_id) = c.node_field {
+        let name = ctx
+            .node_field_name(field_id.get())
+            .map(String::from)
+            .unwrap_or_else(|| format!("field#{}", field_id.get()));
+        format!("{name}: ")
+    } else {
+        String::new()
+    };
+
     let target_name = ctx
         .label_for(c.target)
-        .map(|s| s.to_string())
+        .map(String::from)
         .unwrap_or_else(|| format!("@{:0w$}", c.target.0, w = step_width));
+    let content = format!("{field_part}({target_name})");
+    let successors = format_step(c.next, ctx, step_width);
 
-    let base = format!("  {:0w$}   ▶   ({target_name})", step, w = step_width);
-    pad_to_column(base, 44, &format_step(c.next, ctx, step_width))
+    let base = format!("{prefix}{marker}{content}");
+    pad_to_column(base, cols::TOTAL_WIDTH, &successors)
 }
 
 fn format_return(
     step: u16,
-    r: &Return,
+    _r: &Return,
     _module: &Module,
-    ctx: &DumpContext,
+    _ctx: &DumpContext,
     step_width: usize,
 ) -> String {
-    let name = ctx
-        .entrypoint_name(r.ref_id as usize)
-        .map(|s| s.to_string())
-        .unwrap_or_else(|| format!("ref#{}", r.ref_id));
-
-    let base = format!("  {:0w$}      ({name})", step, w = step_width);
-    pad_to_column(base, 44, "▶")
+    // Return is never epsilon—it's a control flow instruction, not a match
+    let prefix = line_prefix(step, Nav::Stay, false, step_width);
+    // Return just shows the return marker - context makes the definition clear
+    let base = prefix.to_string();
+    pad_to_column(base, cols::TOTAL_WIDTH, "▶")
 }
 
 /// Format a step ID, showing entrypoint label or numeric ID.
@@ -514,16 +580,21 @@ fn format_step(step: StepId, ctx: &DumpContext, step_width: usize) -> String {
     }
 }
 
-/// Format navigation symbol. Called only for non-Stay navigation.
+/// Format navigation symbol as exactly 3 chars (except multi-digit Up levels).
 fn format_nav(nav: Nav) -> String {
     match nav {
-        Nav::Stay => unreachable!("Stay is handled specially in format_match"),
-        Nav::Down => "*↓".to_string(),
-        Nav::DownSkip => "~↓".to_string(),
-        Nav::DownExact => ".↓".to_string(),
-        Nav::Next => "* ".to_string(),
-        Nav::NextSkip => "~ ".to_string(),
-        Nav::NextExact => ". ".to_string(),
+        // Stay: 3 spaces (no movement). The 𝜀 symbol is handled separately
+        // for true epsilon transitions (Stay + no type + no field).
+        Nav::Stay => "   ".to_string(),
+        // Down: space + arrow + modifier
+        Nav::Down => " ↓*".to_string(),
+        Nav::DownSkip => " ↓~".to_string(),
+        Nav::DownExact => " ↓.".to_string(),
+        // Next: centered modifier (no arrow)
+        Nav::Next => " * ".to_string(),
+        Nav::NextSkip => " ~ ".to_string(),
+        Nav::NextExact => " . ".to_string(),
+        // Up: modifier + arrow + superscript level
         Nav::Up(n) => format!("*↑{}", superscript(n)),
         Nav::UpSkipTrivia(n) => format!("~↑{}", superscript(n)),
         Nav::UpExact(n) => format!(".↑{}", superscript(n)),
@@ -545,14 +616,14 @@ fn superscript(n: u8) -> String {
 fn format_effect(effect: &super::EffectOp) -> String {
     match effect.opcode {
         EffectOpcode::Node => "Node".to_string(),
-        EffectOpcode::A => "A".to_string(),
+        EffectOpcode::Arr => "Arr".to_string(),
         EffectOpcode::Push => "Push".to_string(),
-        EffectOpcode::EndA => "EndA".to_string(),
-        EffectOpcode::S => "S".to_string(),
-        EffectOpcode::EndS => "EndS".to_string(),
+        EffectOpcode::EndArr => "EndArr".to_string(),
+        EffectOpcode::Obj => "Obj".to_string(),
+        EffectOpcode::EndObj => "EndObj".to_string(),
         EffectOpcode::Set => format!("Set(M{})", effect.payload),
-        EffectOpcode::E => format!("E(M{})", effect.payload),
-        EffectOpcode::EndE => "EndE".to_string(),
+        EffectOpcode::Enum => format!("Enum(M{})", effect.payload),
+        EffectOpcode::EndEnum => "EndEnum".to_string(),
         EffectOpcode::Text => "Text".to_string(),
         EffectOpcode::Clear => "Clear".to_string(),
         EffectOpcode::Null => "Null".to_string(),
diff --git a/crates/plotnik-lib/src/bytecode/dump_tests.rs b/crates/plotnik-lib/src/bytecode/dump_tests.rs
index 1121b82b..705b5e18 100644
--- a/crates/plotnik-lib/src/bytecode/dump_tests.rs
+++ b/crates/plotnik-lib/src/bytecode/dump_tests.rs
@@ -35,12 +35,12 @@ fn dump_minimal() {
     Test = 01 :: T03
 
     [code]
-      00   𝜀                                    ◼
+      00  𝜀                                     ◼
 
     Test:
-      01   𝜀                                    02
-      02  *↓   (identifier)                     03
-      03   𝜀   [Node Set(M0)]                   ◼
+      01  𝜀                                     02
+      02       (identifier) [Node Set(M0)]      04
+      04                                        ▶
     "#);
 }
 
@@ -127,5 +127,635 @@ fn dump_comprehensive() {
 
     let res = Query::expect_valid_linked_bytecode(input);
 
-    insta::assert_snapshot!(res);
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = true
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "name"
+    S02 "value"
+    S03 "Literal"
+    S04 "Variable"
+    S05 "target"
+    S06 "Ident"
+    S07 "Expression"
+    S08 "Assignment"
+    S09 "identifier"
+    S10 "number"
+    S11 "assignment_expression"
+    S12 "left"
+    S13 "right"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 1)  ; { name }
+    T04 = Struct(M1, 1)  ; { value }
+    T05 = Struct(M2, 1)  ; { name }
+    T06 = Enum(M3, 2)  ; Literal | Variable
+    T07 = Struct(M5, 2)  ; { value, target }
+
+    [types.members]
+    M0 = (S01, T02)  ; name: str
+    M1 = (S02, T01)  ; value: Node
+    M2 = (S01, T01)  ; name: Node
+    M3 = (S03, T04)  ; Literal: T04
+    M4 = (S04, T05)  ; Variable: T05
+    M5 = (S02, T06)  ; value: Expression
+    M6 = (S05, T01)  ; target: Node
+
+    [types.names]
+    N0 = (S06, T03)  ; Ident
+    N1 = (S07, T06)  ; Expression
+    N2 = (S08, T07)  ; Assignment
+
+    [entry]
+    Assignment = 08 :: T07
+    Expression = 05 :: T06
+    Ident      = 01 :: T03
+
+    [code]
+      00  𝜀                                     ◼
+
+    Ident:
+      01  𝜀                                     02
+      02       (identifier) [Text Set(M0)]      04
+      04                                        ▶
+
+    Expression:
+      05  𝜀                                     06
+      06  𝜀                                     22, 28
+
+    Assignment:
+      08  𝜀                                     09
+      09       (assignment_expression)          10
+      10  ↓*   left: (identifier) [Node Set(M6)]12
+      12  *  ▶ right: (Expression)              13
+      13  𝜀    [Set(M5)]                        15
+      15 *↑¹                                    16
+      16                                        ▶
+      17                                        ▶
+      18  𝜀    [EndEnum]                        17
+      20       (number) [Node Set(M1)]          18
+      22  𝜀    [Enum(M3)]                       20
+      24  𝜀    [EndEnum]                        17
+      26       (identifier) [Node Set(M2)]      24
+      28  𝜀    [Enum(M4)]                       26
+    "#);
+}
+
+/// Regression test for nested bubble captures.
+///
+/// Previously, deeply nested bubble captures (3+ levels) produced incorrect
+/// member indices. The innermost captures were offset incorrectly because
+/// each bubble capture pushed an intermediate type as the scope, but those
+/// types weren't emitted to bytecode. The fix ensures bubble captures don't
+/// push new scopes, so all member lookups reference the root struct.
+#[test]
+fn dump_nested_bubble_captures_three_levels() {
+    // 3 levels of nested bubble captures: @a wraps @b wraps @c
+    let input = "Test = (a (b (c) @c) @b) @a";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Verify member indices: @c should use M2, @b should use M1, @a should use M0
+    // Previously this would incorrectly produce: @c→M1, @b→M0, @a→M0
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = false
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "a"
+    S02 "b"
+    S03 "c"
+    S04 "Test"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 3)  ; { a, b, c }
+
+    [types.members]
+    M0 = (S01, T01)  ; a: Node
+    M1 = (S02, T01)  ; b: Node
+    M2 = (S03, T01)  ; c: Node
+
+    [types.names]
+    N0 = (S04, T03)  ; Test
+
+    [entry]
+    Test = 01 :: T03
+
+    [code]
+      00  𝜀                                     ◼
+
+    Test:
+      01  𝜀                                     02
+      02       (a) [Node Set(M0)]               04
+      04  ↓*   (b) [Node Set(M1)]               06
+      06  ↓*   (c) [Node Set(M2)]               08
+      08 *↑¹                                    09
+      09 *↑¹                                    10
+      10                                        ▶
+    "#);
+}
+
+#[test]
+fn dump_nested_bubble_captures_four_levels() {
+    // 4 levels of nested bubble captures
+    let input = "Test = (a (b (c (d) @d) @c) @b) @a";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Verify all member indices are correct
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = false
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "a"
+    S02 "b"
+    S03 "c"
+    S04 "d"
+    S05 "Test"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 4)  ; { a, b, c, d }
+
+    [types.members]
+    M0 = (S01, T01)  ; a: Node
+    M1 = (S02, T01)  ; b: Node
+    M2 = (S03, T01)  ; c: Node
+    M3 = (S04, T01)  ; d: Node
+
+    [types.names]
+    N0 = (S05, T03)  ; Test
+
+    [entry]
+    Test = 01 :: T03
+
+    [code]
+      00  𝜀                                     ◼
+
+    Test:
+      01  𝜀                                     02
+      02       (a) [Node Set(M0)]               04
+      04  ↓*   (b) [Node Set(M1)]               06
+      06  ↓*   (c) [Node Set(M2)]               08
+      08  ↓*   (d) [Node Set(M3)]               10
+      10 *↑¹                                    11
+      11 *↑¹                                    12
+      12 *↑¹                                    13
+      13                                        ▶
+    "#);
+}
+
+/// Regression test for quantifier repeat navigation.
+///
+/// Previously, repeat iterations in */+ quantifiers used None for navigation,
+/// defaulting to Stay. This caused infinite loops because the VM would match
+/// the same node forever instead of advancing to the next sibling.
+#[test]
+fn dump_quantifier_repeat_navigation() {
+    let input = "Test = (function_declaration (decorator)* @decs)";
+
+    let res = Query::expect_valid_linked_bytecode(input);
+
+    // The first iteration should use Down (↓*), repeat should use Next (*)
+    // Previously, the repeat iteration had no navigation (stayed on same node)
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = true
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "decs"
+    S02 "Test"
+    S03 "function_declaration"
+    S04 "decorator"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = ArrayStar(T01)  ; Node*
+    T04 = Struct(M0, 1)  ; { decs }
+
+    [types.members]
+    M0 = (S01, T03)  ; decs: T03
+
+    [types.names]
+    N0 = (S02, T04)  ; Test
+
+    [entry]
+    Test = 01 :: T04
+
+    [code]
+      00  𝜀                                     ◼
+
+    Test:
+      01  𝜀                                     02
+      02       (function_declaration)           03
+      03  𝜀    [Arr]                            05
+      05  𝜀                                     13, 11
+      07  𝜀    [EndArr Set(M0)]                 09
+      09 *↑¹                                    10
+      10                                        ▶
+      11  𝜀    [EndArr Set(M0)]                 10
+      13  ↓*   (decorator) [Push]               17
+      15  *    (decorator) [Push]               17
+      17  𝜀                                     15, 07
+    "#);
+}
+
+/// Regression test for Null effect emission in alternations.
+///
+/// When a capture appears in some alternation branches but not others,
+/// the compiler must inject Null Set(member) for the missing fields.
+/// This ensures the output object always has all fields defined.
+#[test]
+fn dump_alternation_null_injection() {
+    let input = "Test = [(identifier) @x (number) @y]";
+
+    let res = Query::expect_valid_linked_bytecode(input);
+
+    // Branch 1 (identifier @x) should inject Null Set(M1) for missing @y
+    // Branch 2 (number @y) should inject Null Set(M0) for missing @x
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = true
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "x"
+    S02 "y"
+    S03 "Test"
+    S04 "identifier"
+    S05 "number"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 2)  ; { x, y }
+    T04 = Optional(T01)  ; Node?
+
+    [types.members]
+    M0 = (S01, T04)  ; x: T04
+    M1 = (S02, T04)  ; y: T04
+
+    [types.names]
+    N0 = (S03, T03)  ; Test
+
+    [entry]
+    Test = 01 :: T03
+
+    [code]
+      00  𝜀                                     ◼
+
+    Test:
+      01  𝜀                                     02
+      02  𝜀                                     07, 11
+      04                                        ▶
+      05       (identifier) [Node Set(M0)]      04
+      07  𝜀    [Null Set(M1)]                   05
+      09       (number) [Node Set(M1)]          04
+      11  𝜀    [Null Set(M0)]                   09
+    "#);
+}
+
+/// Regression test for captured tagged alternation effect placement.
+///
+/// When a tagged alternation has an outer capture like `[A: (x) @a] @item`,
+/// the outer capture's Set effect must go on the EndEnum step, not on the
+/// branch body. Otherwise the field receives a Node instead of the enum.
+#[test]
+fn dump_captured_tagged_alternation() {
+    let input = "Q = [A: (identifier) @a  B: (number) @b] @item";
+
+    let res = Query::expect_valid_linked_bytecode(input);
+
+    // The Set(M3) for @item should be on the EndEnum step, not with Node Set(M0/M1)
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = true
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "a"
+    S02 "b"
+    S03 "A"
+    S04 "B"
+    S05 "item"
+    S06 "Q"
+    S07 "identifier"
+    S08 "number"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 1)  ; { a }
+    T04 = Struct(M1, 1)  ; { b }
+    T05 = Enum(M2, 2)  ; A | B
+    T06 = Struct(M4, 1)  ; { item }
+
+    [types.members]
+    M0 = (S01, T01)  ; a: Node
+    M1 = (S02, T01)  ; b: Node
+    M2 = (S03, T03)  ; A: T03
+    M3 = (S04, T04)  ; B: T04
+    M4 = (S05, T05)  ; item: T05
+
+    [types.names]
+    N0 = (S06, T06)  ; Q
+
+    [entry]
+    Q = 01 :: T06
+
+    [code]
+      00  𝜀                                     ◼
+
+    Q:
+      01  𝜀                                     02
+      02  𝜀                                     09, 15
+      04                                        ▶
+      05  𝜀    [EndEnum Set(M4)]                04
+      07       (identifier) [Node Set(M0)]      05
+      09  𝜀    [Enum(M2)]                       07
+      11  𝜀    [EndEnum Set(M4)]                04
+      13       (number) [Node Set(M1)]          11
+      15  𝜀    [Enum(M3)]                       13
+    "#);
+}
+
+/// Regression test for captured tagged alternation inside quantifier.
+///
+/// Same issue as above, but the outer capture is inside a row quantifier.
+/// The Set effect for @item must be on EndEnum, not on the branch body.
+#[test]
+fn dump_captured_tagged_alternation_in_quantifier() {
+    let input =
+        "Q = (object { [A: (pair) @a  B: (shorthand_property_identifier) @b] @item }* @items)";
+
+    let res = Query::expect_valid_linked_bytecode(input);
+
+    // The Set(M4) for @item should be on the EndEnum step
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = true
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "a"
+    S02 "b"
+    S03 "A"
+    S04 "B"
+    S05 "item"
+    S06 "items"
+    S07 "Q"
+    S08 "object"
+    S09 "pair"
+    S10 "shorthand_property_identifier"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 1)  ; { a }
+    T04 = Struct(M1, 1)  ; { b }
+    T05 = Enum(M2, 2)  ; A | B
+    T06 = Struct(M4, 1)  ; { item }
+    T07 = ArrayStar(T06)  ; T06*
+    T08 = Struct(M5, 1)  ; { items }
+
+    [types.members]
+    M0 = (S01, T01)  ; a: Node
+    M1 = (S02, T01)  ; b: Node
+    M2 = (S03, T03)  ; A: T03
+    M3 = (S04, T04)  ; B: T04
+    M4 = (S05, T05)  ; item: T05
+    M5 = (S06, T07)  ; items: T07
+
+    [types.names]
+    N0 = (S07, T08)  ; Q
+
+    [entry]
+    Q = 01 :: T08
+
+    [code]
+      00  𝜀                                     ◼
+
+    Q:
+      01  𝜀                                     02
+      02       (object)                         03
+      03  𝜀    [Arr]                            05
+      05  𝜀                                     29, 11
+      07  𝜀    [EndArr Set(M5)]                 09
+      09 *↑¹                                    10
+      10                                        ▶
+      11  𝜀    [EndArr Set(M5)]                 10
+      13  𝜀    [EndObj Push]                    49
+      15  𝜀    [EndEnum Set(M4)]                13
+      17  ↓*   (pair) [Node Set(M0)]            15
+      19  𝜀    [Enum(M2)]                       17
+      21  𝜀    [EndEnum Set(M4)]                13
+      23  ↓*   (shorthand_property_identifier) [Node Set(M1)]21
+      25  𝜀    [Enum(M3)]                       23
+      27  𝜀                                     19, 25
+      29  𝜀    [Obj]                            27
+      31  𝜀    [EndObj Push]                    49
+      33  𝜀    [EndEnum Set(M4)]                31
+      35  *    (pair) [Node Set(M0)]            33
+      37  𝜀    [Enum(M2)]                       35
+      39  𝜀    [EndEnum Set(M4)]                31
+      41  *    (shorthand_property_identifier) [Node Set(M1)]39
+      43  𝜀    [Enum(M3)]                       41
+      45  𝜀                                     37, 43
+      47  𝜀    [Obj]                            45
+      49  𝜀                                     47, 07
+    "#);
+}
+
+/// Regression test: alternation capture without internal captures needs Node effect.
+///
+/// Bug: `[(identifier) (number)] @x` was missing the Node effect, producing
+/// just `[Set(M0)]` instead of `[Node Set(M0)]`. The alternation doesn't have
+/// internal captures, so it produces a Node value, not a Struct.
+#[test]
+fn regression_alternation_capture_node_effect() {
+    let input = "Q = (program [(identifier) (number)] @x)";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Both branches must have [Node Set(M0)], not just [Set(M0)]
+    assert!(
+        res.contains("[Node Set(M0)]"),
+        "Missing Node effect on alternation capture"
+    );
+    // Should appear twice (once per branch)
+    assert_eq!(
+        res.matches("[Node Set(M0)]").count(),
+        2,
+        "Node effect should appear on both alternation branches"
+    );
+}
+
+/// Regression test: optional first-child skip path needs Down navigation.
+///
+/// Bug: When `(parent (child)? @a (sibling) @b)` skips the optional, the sibling
+/// was compiled with Next navigation, but we never descended into parent's children.
+/// The skip path must use Down navigation for the first non-skipped child.
+#[test]
+fn regression_optional_first_child_skip_navigation() {
+    let input = "Q = (program (identifier)? @id (number) @n)";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Should have TWO versions of (number):
+    // 1. With ↓* (Down) for skip path
+    // 2. With * (Next) for after-match path
+    assert!(
+        res.contains("↓*   (number)"),
+        "Skip path should have Down navigation for (number)"
+    );
+    assert!(
+        res.contains("*    (number)"),
+        "Match path should have Next navigation for (number)"
+    );
+}
+
+/// Regression test: optional skip path needs Null injection for captures.
+///
+/// Bug: When `(parent (child)? @a)` skips the optional, the field @a was never
+/// set to null. Alternations correctly inject `[Null Set(Mx)]` for missing
+/// captures, but optionals didn't.
+#[test]
+fn regression_optional_skip_null_injection() {
+    let input = "Q = (function_declaration (decorator)? @dec)";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Skip path must have [Null Set(M0)] to set @dec to null
+    assert!(
+        res.contains("[Null Set(M0)]"),
+        "Skip path should inject Null for optional capture"
+    );
+}
+
+/// Regression test: star first-child with array capture preserves Arr/EndArr.
+///
+/// Bug: When compiling `(parent (child)* @arr (sibling) @s)` as first-child,
+/// the array scope (Arr/EndArr) was being stripped. The fix must preserve
+/// array semantics while also handling skip navigation.
+#[test]
+fn regression_star_first_child_array_capture() {
+    let input = "Q = (array (identifier)* @ids (number) @n)";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Must have Arr and EndArr for array semantics
+    assert!(res.contains("[Arr]"), "Array capture must have Arr effect");
+    assert!(
+        res.contains("[EndArr Set(M0)]"),
+        "Array capture must have EndArr with Set"
+    );
+
+    // Must have TWO versions of (number) for skip/match paths
+    assert!(
+        res.contains("↓*   (number)"),
+        "Skip path should have Down navigation"
+    );
+    assert!(
+        res.contains("*    (number)"),
+        "Match path should have Next navigation"
+    );
+}
+
+/// Regression test: struct array with internal captures needs Obj/EndObj.
+///
+/// Bug: When `{(a) @a (b) @b}* @items` is compiled, the struct boundaries
+/// (Obj/EndObj) and Set effects are missing. Each iteration should produce:
+/// Obj → Node Set(M0) → Node Set(M1) → EndObj Push
+#[test]
+fn regression_struct_array_internal_captures() {
+    let input = "Q = (array {(identifier) @a (number) @b}* @items)";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Must have Obj/EndObj for struct boundaries
+    assert!(res.contains("[Obj]"), "Struct array must have Obj effect");
+    assert!(
+        res.contains("[EndObj"),
+        "Struct array must have EndObj effect"
+    );
+
+    // Must have Set effects for internal captures
+    assert!(res.contains("Set(M0)"), "Must have Set effect for @a");
+    assert!(res.contains("Set(M1)"), "Must have Set effect for @b");
+
+    // Full snapshot to verify correct structure
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = false
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "a"
+    S02 "b"
+    S03 "items"
+    S04 "Q"
+    S05 "array"
+    S06 "number"
+    S07 "identifier"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 2)  ; { a, b }
+    T04 = ArrayStar(T03)  ; T03*
+    T05 = Struct(M2, 1)  ; { items }
+
+    [types.members]
+    M0 = (S01, T01)  ; a: Node
+    M1 = (S02, T01)  ; b: Node
+    M2 = (S03, T04)  ; items: T04
+
+    [types.names]
+    N0 = (S04, T05)  ; Q
+
+    [entry]
+    Q = 01 :: T05
+
+    [code]
+      00  𝜀                                     ◼
+
+    Q:
+      01  𝜀                                     02
+      02       (array)                          03
+      03  𝜀    [Arr]                            05
+      05  𝜀                                     19, 11
+      07  𝜀    [EndArr Set(M2)]                 09
+      09 *↑¹                                    10
+      10                                        ▶
+      11  𝜀    [EndArr Set(M2)]                 10
+      13  𝜀    [EndObj Push]                    29
+      15  *    (number) [Node Set(M1)]          13
+      17  ↓*   (identifier) [Node Set(M0)]      15
+      19  𝜀    [Obj]                            17
+      21  𝜀    [EndObj Push]                    29
+      23  *    (number) [Node Set(M1)]          21
+      25  *    (identifier) [Node Set(M0)]      23
+      27  𝜀    [Obj]                            25
+      29  𝜀                                     27, 07
+    "#);
 }
diff --git a/crates/plotnik-lib/src/bytecode/effects.rs b/crates/plotnik-lib/src/bytecode/effects.rs
index 8f52983c..879730cb 100644
--- a/crates/plotnik-lib/src/bytecode/effects.rs
+++ b/crates/plotnik-lib/src/bytecode/effects.rs
@@ -4,14 +4,14 @@
 #[repr(u8)]
 pub enum EffectOpcode {
     Node = 0,
-    A = 1,
+    Arr = 1,
     Push = 2,
-    EndA = 3,
-    S = 4,
-    EndS = 5,
+    EndArr = 3,
+    Obj = 4,
+    EndObj = 5,
     Set = 6,
-    E = 7,
-    EndE = 8,
+    Enum = 7,
+    EndEnum = 8,
     Text = 9,
     Clear = 10,
     Null = 11,
@@ -21,14 +21,14 @@ impl EffectOpcode {
     fn from_u8(v: u8) -> Self {
         match v {
             0 => Self::Node,
-            1 => Self::A,
+            1 => Self::Arr,
             2 => Self::Push,
-            3 => Self::EndA,
-            4 => Self::S,
-            5 => Self::EndS,
+            3 => Self::EndArr,
+            4 => Self::Obj,
+            5 => Self::EndObj,
             6 => Self::Set,
-            7 => Self::E,
-            8 => Self::EndE,
+            7 => Self::Enum,
+            8 => Self::EndEnum,
             9 => Self::Text,
             10 => Self::Clear,
             11 => Self::Null,
@@ -93,7 +93,7 @@ mod tests {
     #[test]
     fn max_payload() {
         let op = EffectOp {
-            opcode: EffectOpcode::E,
+            opcode: EffectOpcode::Enum,
             payload: 1023,
         };
         let bytes = op.to_bytes();
diff --git a/crates/plotnik-lib/src/bytecode/instructions.rs b/crates/plotnik-lib/src/bytecode/instructions.rs
index c9dd6921..49876ada 100644
--- a/crates/plotnik-lib/src/bytecode/instructions.rs
+++ b/crates/plotnik-lib/src/bytecode/instructions.rs
@@ -467,12 +467,14 @@ impl<'a> MatchView<'a> {
 pub struct Call {
     /// Segment index (0-15).
     pub segment: u8,
+    /// Navigation to apply before jumping to target.
+    pub nav: Nav,
+    /// Field constraint (None = no constraint).
+    pub node_field: Option<NonZeroU16>,
     /// Return address (current segment).
     pub next: StepId,
     /// Callee entry point (target segment from type_id).
     pub target: StepId,
-    /// Definition identifier for stack validation.
-    pub ref_id: u16,
 }
 
 impl Call {
@@ -489,9 +491,10 @@ impl Call {
 
         Self {
             segment,
-            next: StepId(u16::from_le_bytes([bytes[2], bytes[3]])),
-            target: StepId(u16::from_le_bytes([bytes[4], bytes[5]])),
-            ref_id: u16::from_le_bytes([bytes[6], bytes[7]]),
+            nav: Nav::from_byte(bytes[1]),
+            node_field: NonZeroU16::new(u16::from_le_bytes([bytes[2], bytes[3]])),
+            next: StepId(u16::from_le_bytes([bytes[4], bytes[5]])),
+            target: StepId(u16::from_le_bytes([bytes[6], bytes[7]])),
         }
     }
 
@@ -499,10 +502,10 @@ impl Call {
     pub fn to_bytes(&self) -> [u8; 8] {
         let mut bytes = [0u8; 8];
         bytes[0] = (self.segment << 4) | (Opcode::Call as u8);
-        // bytes[1] is reserved
-        bytes[2..4].copy_from_slice(&self.next.0.to_le_bytes());
-        bytes[4..6].copy_from_slice(&self.target.0.to_le_bytes());
-        bytes[6..8].copy_from_slice(&self.ref_id.to_le_bytes());
+        bytes[1] = self.nav.to_byte();
+        bytes[2..4].copy_from_slice(&self.node_field.map_or(0, |v| v.get()).to_le_bytes());
+        bytes[4..6].copy_from_slice(&self.next.0.to_le_bytes());
+        bytes[6..8].copy_from_slice(&self.target.0.to_le_bytes());
         bytes
     }
 }
@@ -512,8 +515,6 @@ impl Call {
 pub struct Return {
     /// Segment index (0-15).
     pub segment: u8,
-    /// Definition identifier for stack validation.
-    pub ref_id: u16,
 }
 
 impl Return {
@@ -528,19 +529,14 @@ impl Return {
         let opcode = Opcode::from_u8(type_id_byte & 0xF);
         assert_eq!(opcode, Opcode::Return, "expected Return opcode");
 
-        Self {
-            segment,
-            ref_id: u16::from_le_bytes([bytes[2], bytes[3]]),
-        }
+        Self { segment }
     }
 
     /// Encode to 8-byte bytecode.
     pub fn to_bytes(&self) -> [u8; 8] {
         let mut bytes = [0u8; 8];
         bytes[0] = (self.segment << 4) | (Opcode::Return as u8);
-        // bytes[1] is reserved
-        bytes[2..4].copy_from_slice(&self.ref_id.to_le_bytes());
-        // bytes[4..8] are padding
+        // bytes[1..8] are reserved/padding
         bytes
     }
 }
diff --git a/crates/plotnik-lib/src/bytecode/instructions_tests.rs b/crates/plotnik-lib/src/bytecode/instructions_tests.rs
index c3e21604..581b3af4 100644
--- a/crates/plotnik-lib/src/bytecode/instructions_tests.rs
+++ b/crates/plotnik-lib/src/bytecode/instructions_tests.rs
@@ -110,7 +110,7 @@ fn match_extended_roundtrip() {
         node_type: NonZeroU16::new(100),
         node_field: None,
         pre_effects: vec![EffectOp {
-            opcode: EffectOpcode::S,
+            opcode: EffectOpcode::Obj,
             payload: 0,
         }],
         neg_fields: vec![5, 6],
@@ -139,9 +139,10 @@ fn match_extended_roundtrip() {
 fn call_roundtrip() {
     let c = Call {
         segment: 0,
+        nav: Nav::Down,
+        node_field: NonZeroU16::new(42),
         next: StepId(100),
         target: StepId(500),
-        ref_id: 42,
     };
 
     let bytes = c.to_bytes();
@@ -151,10 +152,7 @@ fn call_roundtrip() {
 
 #[test]
 fn return_roundtrip() {
-    let r = Return {
-        segment: 0,
-        ref_id: 99,
-    };
+    let r = Return { segment: 0 };
 
     let bytes = r.to_bytes();
     let decoded = Return::from_bytes(bytes);
@@ -218,7 +216,7 @@ fn match_view_extended() {
         node_type: NonZeroU16::new(100),
         node_field: None,
         pre_effects: vec![EffectOp {
-            opcode: EffectOpcode::S,
+            opcode: EffectOpcode::Obj,
             payload: 0,
         }],
         neg_fields: vec![5, 6],
@@ -245,7 +243,7 @@ fn match_view_extended() {
     // Check pre_effects
     let pre: Vec<_> = view.pre_effects().collect();
     assert_eq!(pre.len(), 1);
-    assert_eq!(pre[0].opcode, EffectOpcode::S);
+    assert_eq!(pre[0].opcode, EffectOpcode::Obj);
 
     // Check neg_fields
     let neg: Vec<_> = view.neg_fields().collect();
diff --git a/crates/plotnik-lib/src/bytecode/ir.rs b/crates/plotnik-lib/src/bytecode/ir.rs
index 8a7b624c..643c9d06 100644
--- a/crates/plotnik-lib/src/bytecode/ir.rs
+++ b/crates/plotnik-lib/src/bytecode/ir.rs
@@ -246,12 +246,14 @@ impl MatchIR {
 pub struct CallIR {
     /// Where this instruction lives.
     pub label: Label,
+    /// Navigation to apply before jumping to target.
+    pub nav: Nav,
+    /// Field constraint (None = no constraint).
+    pub node_field: Option<NonZeroU16>,
     /// Return address (where to continue after callee returns).
     pub next: Label,
     /// Callee entry point.
     pub target: Label,
-    /// Definition identifier for stack validation.
-    pub ref_id: u16,
 }
 
 impl CallIR {
@@ -259,9 +261,10 @@ impl CallIR {
     pub fn resolve(&self, map: &BTreeMap<Label, StepId>) -> [u8; 8] {
         let c = Call {
             segment: 0,
+            nav: self.nav,
+            node_field: self.node_field,
             next: self.next.resolve(map),
             target: self.target.resolve(map),
-            ref_id: self.ref_id,
         };
         c.to_bytes()
     }
@@ -272,18 +275,12 @@ impl CallIR {
 pub struct ReturnIR {
     /// Where this instruction lives.
     pub label: Label,
-    /// Definition identifier for stack validation.
-    pub ref_id: u16,
 }
 
 impl ReturnIR {
     /// Serialize to bytecode bytes (no labels to resolve).
     pub fn resolve(&self) -> [u8; 8] {
-        let r = Return {
-            segment: 0,
-            ref_id: self.ref_id,
-        };
-
+        let r = Return { segment: 0 };
         r.to_bytes()
     }
 }
@@ -331,7 +328,7 @@ mod tests {
             nav: Nav::Down,
             node_type: NonZeroU16::new(10),
             node_field: None,
-            pre_effects: vec![EffectIR::simple(EffectOpcode::S, 0)],
+            pre_effects: vec![EffectIR::simple(EffectOpcode::Obj, 0)],
             neg_fields: vec![],
             post_effects: vec![EffectIR::simple(EffectOpcode::Node, 0)],
             successors: vec![Label(1)],
@@ -358,16 +355,16 @@ mod tests {
 
         let c = Instruction::Call(CallIR {
             label: Label(3),
+            nav: Nav::Down,
+            node_field: None,
             next: Label(4),
             target: Label(5),
-            ref_id: 0,
         });
 
         assert_eq!(c.successors(), vec![Label(4)]);
 
         let r = Instruction::Return(ReturnIR {
             label: Label(6),
-            ref_id: 0,
         });
 
         assert!(r.successors().is_empty());
diff --git a/crates/plotnik-lib/src/bytecode/layout_tests.rs b/crates/plotnik-lib/src/bytecode/layout_tests.rs
index b1741b43..690a18dc 100644
--- a/crates/plotnik-lib/src/bytecode/layout_tests.rs
+++ b/crates/plotnik-lib/src/bytecode/layout_tests.rs
@@ -93,9 +93,10 @@ fn layout_call_return() {
         }),
         Instruction::Call(CallIR {
             label: Label(1),
+            nav: Nav::Down,
+            node_field: None,
             next: Label(3),
             target: Label(2),
-            ref_id: 0,
         }),
         Instruction::Match(MatchIR {
             label: Label(2),
@@ -119,7 +120,6 @@ fn layout_call_return() {
         }),
         Instruction::Return(ReturnIR {
             label: Label(4),
-            ref_id: 0,
         }),
     ];
 
@@ -191,16 +191,16 @@ fn layout_large_instruction_cache_alignment() {
         node_type: NonZeroU16::new(10),
         node_field: None,
         pre_effects: vec![
-            EffectIR::simple(EffectOpcode::S, 0),
-            EffectIR::simple(EffectOpcode::S, 0),
-            EffectIR::simple(EffectOpcode::S, 0),
+            EffectIR::simple(EffectOpcode::Obj, 0),
+            EffectIR::simple(EffectOpcode::Obj, 0),
+            EffectIR::simple(EffectOpcode::Obj, 0),
         ],
         neg_fields: vec![],
         post_effects: vec![
             EffectIR::simple(EffectOpcode::Node, 0),
-            EffectIR::simple(EffectOpcode::EndS, 0),
-            EffectIR::simple(EffectOpcode::EndS, 0),
-            EffectIR::simple(EffectOpcode::EndS, 0),
+            EffectIR::simple(EffectOpcode::EndObj, 0),
+            EffectIR::simple(EffectOpcode::EndObj, 0),
+            EffectIR::simple(EffectOpcode::EndObj, 0),
         ],
         successors: vec![
             Label::ACCEPT,
diff --git a/crates/plotnik-lib/src/bytecode/snapshots/plotnik_lib__bytecode__dump_tests__dump_comprehensive.snap b/crates/plotnik-lib/src/bytecode/snapshots/plotnik_lib__bytecode__dump_tests__dump_comprehensive.snap
index e47598e5..4afc7c37 100644
--- a/crates/plotnik-lib/src/bytecode/snapshots/plotnik_lib__bytecode__dump_tests__dump_comprehensive.snap
+++ b/crates/plotnik-lib/src/bytecode/snapshots/plotnik_lib__bytecode__dump_tests__dump_comprehensive.snap
@@ -51,31 +51,29 @@ Expression = 05 :: T06
 Ident      = 01 :: T03
 
 [code]
-  00   𝜀                                    ◼
+  00  𝜀                                     ◼
 
 Ident:
-  01   𝜀                                    02
-  02  *↓   (identifier)                     03
-  03   𝜀   [Text Set(M0)]                   ◼
+  01  𝜀                                     02
+  02       (identifier) [Text Set(M0)]      04
+  04                                        ▶
 
 Expression:
-  05   𝜀                                    06
-  06   𝜀                                    23, 30
+  05  𝜀                                     06
+  06  𝜀                                     22, 28
 
 Assignment:
-  08   𝜀                                    09
-  09  *↓   (assignment_expression)          10
-  10   𝜀   left: _                          11
-  11  *↓   (identifier)                     12
-  12   𝜀   [Node Set(M6)]                   14
-  14   𝜀   right: _                         ▶(Expression)
-  15   𝜀   [Node Set(M5)]                   17
-  17  *↑¹                                   ◼
-  18   𝜀   [EndE]                           ◼
-  20   𝜀   [Node Set(M1)]                   18
-  22  *↓   (number)                         20
-  23   𝜀   [E(M3)]                          22
-  25   𝜀   [EndE]                           ◼
-  27   𝜀   [Node Set(M2)]                   25
-  29  *↓   (identifier)                     27
-  30   𝜀   [E(M4)]                          29
+  08  𝜀                                     09
+  09       (assignment_expression)          10
+  10  ↓*   left: (identifier) [Node Set(M6)]12
+  12  *  ▶ right: (Expression)              13
+  13  𝜀    [Set(M5)]                        15
+  15 *↑¹                                    16
+  16                                        ▶
+  17                                        ▶
+  18  𝜀    [EndEnum]                        17
+  20       (number) [Node Set(M1)]          18
+  22  𝜀    [Enum(M3)]                       20
+  24  𝜀    [EndEnum]                        17
+  26       (identifier) [Node Set(M2)]      24
+  28  𝜀    [Enum(M4)]                       26
diff --git a/crates/plotnik-lib/src/query/codegen_tests.rs b/crates/plotnik-lib/src/query/codegen_tests.rs
index 942a2b42..54986180 100644
--- a/crates/plotnik-lib/src/query/codegen_tests.rs
+++ b/crates/plotnik-lib/src/query/codegen_tests.rs
@@ -236,14 +236,15 @@ fn emit_anchor_between_siblings() {
     Test = 01 :: T03
 
     [code]
-      00   𝜀                                    ◼
+      00  𝜀                                     ◼
 
     Test:
-      01   𝜀                                    02
-      02  *↓   (parent)                         03
-      03  *↓   (a)                              04
+      01  𝜀                                     02
+      02       (parent)                         03
+      03  ↓*   (a)                              04
       04  ~    (b)                              05
-      05  *↑¹                                   ◼
+      05 *↑¹                                    06
+      06                                        ▶
     "#);
 }
 
@@ -279,13 +280,14 @@ fn emit_anchor_first_child() {
     Test = 01 :: T03
 
     [code]
-      00   𝜀                                    ◼
+      00  𝜀                                     ◼
 
     Test:
-      01   𝜀                                    02
-      02  *↓   (parent)                         03
-      03  ~↓   (first)                          04
-      04  *↑¹                                   ◼
+      01  𝜀                                     02
+      02       (parent)                         03
+      03  ↓~   (first)                          04
+      04 *↑¹                                    05
+      05                                        ▶
     "#);
 }
 
@@ -321,13 +323,14 @@ fn emit_anchor_last_child() {
     Test = 01 :: T03
 
     [code]
-      00   𝜀                                    ◼
+      00  𝜀                                     ◼
 
     Test:
-      01   𝜀                                    02
-      02  *↓   (parent)                         03
-      03  *↓   (last)                           04
-      04  ~↑¹                                   ◼
+      01  𝜀                                     02
+      02       (parent)                         03
+      03  ↓*   (last)                           04
+      04 ~↑¹                                    05
+      05                                        ▶
     "#);
 }
 
@@ -364,14 +367,15 @@ fn emit_anchor_with_anonymous_node() {
     Test = 01 :: T03
 
     [code]
-      00   𝜀                                    ◼
+      00  𝜀                                     ◼
 
     Test:
-      01   𝜀                                    02
-      02  *↓   (parent)                         03
-      03  *↓   (+)                              04
+      01  𝜀                                     02
+      02       (parent)                         03
+      03  ↓*   (+)                              04
       04  .    (next)                           05
-      05  *↑¹                                   ◼
+      05 *↑¹                                    06
+      06                                        ▶
     "#);
 }
 
@@ -408,13 +412,236 @@ fn emit_no_anchor_uses_next() {
     Test = 01 :: T03
 
     [code]
-      00   𝜀                                    ◼
+      00  𝜀                                     ◼
 
     Test:
-      01   𝜀                                    02
-      02  *↓   (parent)                         03
-      03  *↓   (a)                              04
+      01  𝜀                                     02
+      02       (parent)                         03
+      03  ↓*   (a)                              04
       04  *    (b)                              05
-      05  *↑¹                                   ◼
+      05 *↑¹                                    06
+      06                                        ▶
+    "#);
+}
+
+// Tests for wrapper struct Set() emission (Issue 1 fix)
+
+#[test]
+fn emit_wrapper_struct_set() {
+    // Wrapper struct captures should emit Set() for the wrapper field.
+    // Pattern: {{inner captures} @wrapper}* @outer
+    // The @wrapper capture should Set into the array element type.
+    let input = "Test = {{(identifier) @id (number) @num} @row}* @rows";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Verify Set(M2) is emitted for the @row wrapper field
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = false
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "id"
+    S02 "num"
+    S03 "row"
+    S04 "rows"
+    S05 "Test"
+    S06 "number"
+    S07 "identifier"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 2)  ; { id, num }
+    T04 = Struct(M2, 1)  ; { row }
+    T05 = ArrayStar(T04)  ; T04*
+    T06 = Struct(M3, 1)  ; { rows }
+
+    [types.members]
+    M0 = (S01, T01)  ; id: Node
+    M1 = (S02, T01)  ; num: Node
+    M2 = (S03, T03)  ; row: T03
+    M3 = (S04, T05)  ; rows: T05
+
+    [types.names]
+    N0 = (S05, T06)  ; Test
+
+    [entry]
+    Test = 01 :: T06
+
+    [code]
+      00  𝜀                                     ◼
+
+    Test:
+      01  𝜀                                     02
+      02  𝜀    [Arr]                            04
+      04  𝜀                                     19, 07
+      06                                        ▶
+      07  𝜀    [EndArr Set(M3)]                 06
+      09  𝜀    [EndObj Push]                    33
+      11  𝜀    [EndObj Set(M2)]                 09
+      13  *    (number) [Node Set(M1)]          11
+      15       (identifier) [Node Set(M0)]      13
+      17  𝜀    [Obj]                            15
+      19  𝜀    [Obj]                            17
+      21  𝜀    [EndObj Push]                    33
+      23  𝜀    [EndObj Set(M2)]                 21
+      25  *    (number) [Node Set(M1)]          23
+      27       (identifier) [Node Set(M0)]      25
+      29  𝜀    [Obj]                            27
+      31  𝜀    [Obj]                            29
+      33  𝜀                                     31, 07
+    "#);
+}
+
+#[test]
+fn emit_optional_wrapper_struct_set() {
+    // Optional wrapper struct captures should also emit Set() for the wrapper field.
+    let input = "Test = {{(identifier) @id} @inner}? @outer";
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Verify Set(M1) is emitted for the @inner wrapper field
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = false
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "id"
+    S02 "inner"
+    S03 "outer"
+    S04 "Test"
+    S05 "identifier"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 1)  ; { id }
+    T04 = Struct(M1, 1)  ; { inner }
+    T05 = Struct(M2, 1)  ; { outer }
+    T06 = Optional(T03)  ; T03?
+    T07 = Optional(T04)  ; T04?
+
+    [types.members]
+    M0 = (S01, T01)  ; id: Node
+    M1 = (S02, T06)  ; inner: T06
+    M2 = (S03, T07)  ; outer: T07
+
+    [types.names]
+    N0 = (S04, T05)  ; Test
+
+    [entry]
+    Test = 01 :: T05
+
+    [code]
+      00  𝜀                                     ◼
+
+    Test:
+      01  𝜀                                     02
+      02  𝜀    [Obj]                            04
+      04  𝜀                                     13, 15
+      06                                        ▶
+      07  𝜀    [EndObj Set(M2)]                 06
+      09  𝜀    [EndObj Set(M1)]                 07
+      11       (identifier) [Node Set(M0)]      09
+      13  𝜀    [Obj]                            11
+      15  𝜀    [Null Set(M1)]                   07
+    "#);
+}
+
+// Tests for recursive ref structured result (Issue 2 fix)
+
+#[test]
+fn emit_recursive_ref_structured_result() {
+    // Recursive refs returning structured types should not emit Node before Set.
+    // The Call leaves the structured result pending, which Set directly consumes.
+    let input = indoc! {r#"
+        Expr = [
+          Lit: (number) @value :: string
+          Nested: (call_expression function: (identifier) @fn arguments: (Expr) @inner)
+        ]
+
+        Test = (program (Expr) @expr)
+    "#};
+
+    let res = Query::expect_valid_bytecode(input);
+
+    // Verify [Set(M5)] without Node for @expr capture of recursive ref
+    // Verify [Set(M2)] without Node for @inner capture of recursive ref
+    insta::assert_snapshot!(res, @r#"
+    [header]
+    linked = false
+
+    [strings]
+    S00 "Beauty will save the world"
+    S01 "value"
+    S02 "fn"
+    S03 "inner"
+    S04 "Lit"
+    S05 "Nested"
+    S06 "expr"
+    S07 "Expr"
+    S08 "Test"
+    S09 "number"
+    S10 "call_expression"
+    S11 "arguments"
+    S12 "function"
+    S13 "identifier"
+    S14 "program"
+
+    [types.defs]
+    T00 = void
+    T01 = Node
+    T02 = str
+    T03 = Struct(M0, 1)  ; { value }
+    T04 = Struct(M1, 2)  ; { fn, inner }
+    T05 = Enum(M3, 2)  ; Lit | Nested
+    T06 = Struct(M5, 1)  ; { expr }
+
+    [types.members]
+    M0 = (S01, T02)  ; value: str
+    M1 = (S02, T01)  ; fn: Node
+    M2 = (S03, T05)  ; inner: Expr
+    M3 = (S04, T03)  ; Lit: T03
+    M4 = (S05, T04)  ; Nested: T04
+    M5 = (S06, T05)  ; expr: Expr
+
+    [types.names]
+    N0 = (S07, T05)  ; Expr
+    N1 = (S08, T06)  ; Test
+
+    [entry]
+    Expr = 01 :: T05
+    Test = 04 :: T06
+
+    [code]
+      00  𝜀                                     ◼
+
+    Expr:
+      01  𝜀                                     02
+      02  𝜀                                     19, 27
+
+    Test:
+      04  𝜀                                     05
+      05       (program)                        06
+      06  ↓* ▶ (Expr)                           07
+      07  𝜀    [Set(M5)]                        09
+      09 *↑¹                                    10
+      10                                        ▶
+      11  𝜀    [Set(M2)]                        13
+      13 *↑¹                                    21
+      14                                        ▶
+      15  𝜀    [EndEnum]                        14
+      17       (number) [Text Set(M0)]          15
+      19  𝜀    [Enum(M3)]                       17
+      21  𝜀    [EndEnum]                        14
+      23  *  ▶ arguments: (Expr)                11
+      24  ↓*   function: (identifier) [Node Set(M1)]23
+      26       (call_expression)                24
+      27  𝜀    [Enum(M4)]                       26
     "#);
 }
diff --git a/crates/plotnik-lib/src/query/compile.rs b/crates/plotnik-lib/src/query/compile.rs
deleted file mode 100644
index 7b463207..00000000
--- a/crates/plotnik-lib/src/query/compile.rs
+++ /dev/null
@@ -1,1323 +0,0 @@
-//! Thompson-like NFA construction for query compilation.
-//!
-//! Compiles query AST expressions into bytecode IR with symbolic labels.
-//! Labels are resolved to concrete StepIds during the layout phase.
-//! Member indices use deferred resolution via MemberRef for correct absolute indices.
-
-use std::num::NonZeroU16;
-
-use indexmap::IndexMap;
-use plotnik_core::{Interner, NodeFieldId, NodeTypeId, Symbol};
-
-use crate::bytecode::ir::{CallIR, EffectIR, Instruction, Label, MatchIR, MemberRef, ReturnIR};
-use crate::bytecode::{EffectOpcode, Nav};
-use crate::parser::ast::{self, Expr, SeqItem};
-use crate::parser::cst::SyntaxKind;
-
-use super::codegen::StringTableBuilder;
-use super::symbol_table::SymbolTable;
-use super::type_check::{Arity, DefId, TypeContext, TypeId, TypeShape};
-
-/// Error during compilation.
-#[derive(Clone, Debug)]
-pub enum CompileError {
-    /// Definition not found in symbol table.
-    DefinitionNotFound(String),
-    /// Expression body missing.
-    MissingBody(String),
-}
-
-impl std::fmt::Display for CompileError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::DefinitionNotFound(name) => write!(f, "definition not found: {name}"),
-            Self::MissingBody(name) => write!(f, "missing body for definition: {name}"),
-        }
-    }
-}
-
-impl std::error::Error for CompileError {}
-
-/// Result of compilation.
-#[derive(Clone, Debug)]
-pub struct CompileResult {
-    /// All generated instructions.
-    pub instructions: Vec<Instruction>,
-    /// Entry labels for each definition (in definition order).
-    pub def_entries: IndexMap<DefId, Label>,
-}
-
-/// Struct scope for tracking captures in nested contexts.
-/// Each scope represents a struct type whose fields can receive captures.
-#[derive(Clone, Copy, Debug)]
-struct StructScope(TypeId);
-
-/// Compiler state for Thompson construction.
-pub struct Compiler<'a> {
-    interner: &'a Interner,
-    type_ctx: &'a TypeContext,
-    symbol_table: &'a SymbolTable,
-    strings: &'a mut StringTableBuilder,
-    node_type_ids: Option<&'a IndexMap<Symbol, NodeTypeId>>,
-    node_field_ids: Option<&'a IndexMap<Symbol, NodeFieldId>>,
-    instructions: Vec<Instruction>,
-    next_label_id: u32,
-    def_entries: IndexMap<DefId, Label>,
-    ref_id_counter: u16,
-    /// Stack of active struct scopes for capture lookup.
-    /// Innermost scope is at the end.
-    scope_stack: Vec<StructScope>,
-}
-
-impl<'a> Compiler<'a> {
-    /// Create a new compiler.
-    pub fn new(
-        interner: &'a Interner,
-        type_ctx: &'a TypeContext,
-        symbol_table: &'a SymbolTable,
-        strings: &'a mut StringTableBuilder,
-        node_type_ids: Option<&'a IndexMap<Symbol, NodeTypeId>>,
-        node_field_ids: Option<&'a IndexMap<Symbol, NodeFieldId>>,
-    ) -> Self {
-        Self {
-            interner,
-            type_ctx,
-            symbol_table,
-            strings,
-            node_type_ids,
-            node_field_ids,
-            instructions: Vec::new(),
-            next_label_id: 0,
-            def_entries: IndexMap::new(),
-            ref_id_counter: 0,
-            scope_stack: Vec::new(),
-        }
-    }
-
-    /// Compile all definitions in the query.
-    pub fn compile(
-        interner: &'a Interner,
-        type_ctx: &'a TypeContext,
-        symbol_table: &'a SymbolTable,
-        strings: &'a mut StringTableBuilder,
-        node_type_ids: Option<&'a IndexMap<Symbol, NodeTypeId>>,
-        node_field_ids: Option<&'a IndexMap<Symbol, NodeFieldId>>,
-    ) -> Result<CompileResult, CompileError> {
-        let mut compiler = Self::new(interner, type_ctx, symbol_table, strings, node_type_ids, node_field_ids);
-
-        // Pre-allocate entry labels for all definitions
-        for (def_id, _) in type_ctx.iter_def_types() {
-            let label = compiler.fresh_label();
-            compiler.def_entries.insert(def_id, label);
-        }
-
-        // Compile each definition
-        for (def_id, _) in type_ctx.iter_def_types() {
-            compiler.compile_def(def_id)?;
-        }
-
-        Ok(CompileResult {
-            instructions: compiler.instructions,
-            def_entries: compiler.def_entries,
-        })
-    }
-
-    /// Generate a fresh label.
-    fn fresh_label(&mut self) -> Label {
-        let l = Label(self.next_label_id);
-        self.next_label_id += 1;
-        l
-    }
-
-    /// Generate a fresh ref_id for Call/Return verification.
-    fn fresh_ref_id(&mut self) -> u16 {
-        let id = self.ref_id_counter;
-        self.ref_id_counter += 1;
-        id
-    }
-
-    /// Compile a single definition.
-    fn compile_def(&mut self, def_id: DefId) -> Result<(), CompileError> {
-        let name_sym = self.type_ctx.def_name_sym(def_id);
-        let name = self.interner.resolve(name_sym);
-
-        let Some(body) = self.symbol_table.get(name) else {
-            return Err(CompileError::DefinitionNotFound(name.to_string()));
-        };
-
-        let entry_label = self.def_entries[&def_id];
-
-        // Compile body with root scope, targeting accept state
-        let body_entry = if let Some(type_id) = self.type_ctx.get_def_type(def_id) {
-            self.with_scope(type_id, |this| this.compile_expr(body, Label::ACCEPT))
-        } else {
-            self.compile_expr(body, Label::ACCEPT)
-        };
-
-        // If body_entry differs from our pre-allocated entry, emit an epsilon jump
-        if body_entry != entry_label {
-            self.emit_epsilon(entry_label, vec![body_entry]);
-        }
-
-        Ok(())
-    }
-
-    /// Compile an expression, returning its entry label.
-    fn compile_expr(&mut self, expr: &Expr, exit: Label) -> Label {
-        match expr {
-            Expr::NamedNode(n) => self.compile_named_node(n, exit),
-            Expr::AnonymousNode(n) => self.compile_anonymous_node(n, exit),
-            Expr::Ref(r) => self.compile_ref(r, exit),
-            Expr::SeqExpr(s) => self.compile_seq(s, exit),
-            Expr::AltExpr(a) => self.compile_alt(a, exit),
-            Expr::QuantifiedExpr(q) => self.compile_quantified(q, exit),
-            Expr::FieldExpr(f) => self.compile_field(f, exit),
-            Expr::CapturedExpr(c) => self.compile_captured(c, exit),
-        }
-    }
-
-    /// Compile a named node: `(identifier)` or `(call_expression arg: ...)`.
-    fn compile_named_node(&mut self, node: &ast::NamedNode, exit: Label) -> Label {
-        self.compile_named_node_with_nav(node, exit, None)
-    }
-
-    /// Check if an expression is anonymous (string literal or wildcard).
-    fn expr_is_anonymous(&self, expr: Option<&Expr>) -> bool {
-        matches!(expr, Some(Expr::AnonymousNode(_)))
-    }
-
-    /// Check for trailing anchor in items, looking inside sequences if needed.
-    /// Returns (has_trailing_anchor, is_strict).
-    fn check_trailing_anchor(&self, items: &[SeqItem]) -> (bool, bool) {
-        // Direct trailing anchor
-        if matches!(items.last(), Some(SeqItem::Anchor(_))) {
-            let prev_expr = items.iter().rev().skip(1).find_map(|item| {
-                if let SeqItem::Expr(e) = item { Some(e) } else { None }
-            });
-            return (true, self.expr_is_anonymous(prev_expr));
-        }
-
-        // Check if only child is a sequence with trailing anchor
-        if items.len() == 1
-            && let Some(SeqItem::Expr(Expr::SeqExpr(seq))) = items.first()
-        {
-            let seq_items: Vec<_> = seq.items().collect();
-            return self.check_trailing_anchor(&seq_items);
-        }
-
-        (false, false)
-    }
-
-    /// Compile sequence items (expressions and anchors).
-    ///
-    /// Handles anchor semantics:
-    /// - First child uses Down, subsequent use Next
-    /// - Anchors determine strictness (Skip vs Exact)
-    /// - Leading anchors affect first child navigation
-    /// - Trailing anchors affect Up instruction (handled by caller)
-    fn compile_seq_items(&mut self, items: &[SeqItem], exit: Label, is_inside_node: bool) -> Label {
-        self.compile_seq_items_with_first_nav(items, exit, is_inside_node, None)
-    }
-
-    /// Compile sequence items with optional external nav override for first item.
-    fn compile_seq_items_with_first_nav(
-        &mut self,
-        items: &[SeqItem],
-        exit: Label,
-        is_inside_node: bool,
-        first_nav: Option<Nav>,
-    ) -> Label {
-        // Compute navigation modes first (immutable borrow)
-        let mut nav_modes = Self::compute_nav_modes(items, is_inside_node);
-
-        if nav_modes.is_empty() {
-            return exit;
-        }
-
-        // Apply navigation to first expression:
-        // 1. External nav (first_nav) takes precedence if provided
-        // 2. If no external nav but inside node, default to Down
-        // 3. Internal anchors (already computed) override these defaults
-        if let Some((_, first_mode)) = nav_modes.first_mut()
-            && first_mode.is_none()
-        {
-            *first_mode = first_nav.or_else(|| is_inside_node.then_some(Nav::Down));
-        }
-
-        // Build chain in reverse: last expression exits to `exit`, each prior exits to next
-        let mut current_exit = exit;
-        for (expr_idx, nav_override) in nav_modes.into_iter().rev() {
-            let expr = items[expr_idx].as_expr().expect("nav_modes only contains expr indices");
-            current_exit = self.compile_expr_with_nav(expr, current_exit, nav_override);
-        }
-        current_exit
-    }
-
-    /// Compute navigation modes for each expression based on anchor context.
-    /// Returns a vector of (expression index, nav mode) pairs.
-    fn compute_nav_modes(items: &[SeqItem], is_inside_node: bool) -> Vec<(usize, Option<Nav>)> {
-        let mut result = Vec::new();
-        let mut pending_anchor = false;
-        let mut prev_is_anonymous = false;
-        let mut is_first_expr = true;
-
-        for (idx, item) in items.iter().enumerate() {
-            match item {
-                SeqItem::Anchor(_) => {
-                    pending_anchor = true;
-                }
-                SeqItem::Expr(expr) => {
-                    let current_is_anonymous = matches!(expr, Expr::AnonymousNode(_));
-                    let nav = if pending_anchor {
-                        // Anchor between previous item and this one
-                        let is_exact = prev_is_anonymous || current_is_anonymous;
-                        if is_first_expr && is_inside_node {
-                            // First child with leading anchor
-                            Some(if is_exact { Nav::DownExact } else { Nav::DownSkip })
-                        } else if !is_first_expr {
-                            // Sibling with anchor
-                            Some(if is_exact { Nav::NextExact } else { Nav::NextSkip })
-                        } else {
-                            // First in sequence (not inside node)
-                            None
-                        }
-                    } else if !is_first_expr {
-                        // Normal sibling navigation (no anchor)
-                        Some(Nav::Next)
-                    } else {
-                        // First expression - use default (None for sequences, Down for nodes)
-                        None
-                    };
-
-                    result.push((idx, nav));
-                    pending_anchor = false;
-                    prev_is_anonymous = current_is_anonymous;
-                    is_first_expr = false;
-                }
-            }
-        }
-
-        result
-    }
-
-    /// Compile an expression with an optional navigation override.
-    fn compile_expr_with_nav(&mut self, expr: &Expr, exit: Label, nav_override: Option<Nav>) -> Label {
-        match expr {
-            // For expressions that emit their own Match instructions,
-            // we need to modify the navigation mode
-            Expr::NamedNode(n) => self.compile_named_node_with_nav(n, exit, nav_override),
-            Expr::AnonymousNode(n) => self.compile_anonymous_node_with_nav(n, exit, nav_override),
-            // For sequences and alternations, propagate nav to first item(s)
-            Expr::SeqExpr(s) => self.compile_seq_with_nav(s, exit, nav_override),
-            Expr::AltExpr(a) => self.compile_alt_with_nav(a, exit, nav_override),
-            // For wrapper expressions, propagate nav to inner expression
-            Expr::CapturedExpr(c) => self.compile_captured_with_nav(c, exit, nav_override),
-            Expr::QuantifiedExpr(q) => self.compile_quantified_with_nav(q, exit, nav_override),
-            Expr::FieldExpr(f) => self.compile_field_with_nav(f, exit, nav_override),
-            Expr::Ref(r) => self.compile_ref_with_nav(r, exit, nav_override),
-        }
-    }
-
-    /// Compile a named node: `(identifier)` or `(call_expression arg: ...)`.
-    ///
-    /// If `nav_override` is provided, uses that navigation instead of the default `Down`.
-    fn compile_named_node_with_nav(&mut self, node: &ast::NamedNode, exit: Label, nav_override: Option<Nav>) -> Label {
-        let entry = self.fresh_label();
-        let node_type = self.resolve_node_type(node);
-        let nav = nav_override.unwrap_or(Nav::Down);
-
-        // Collect items and negated fields
-        let items: Vec<_> = node.items().collect();
-        let neg_fields = self.collect_neg_fields(node);
-
-        // If no items, just match and exit
-        if items.is_empty() {
-            self.instructions.push(Instruction::Match(MatchIR {
-                label: entry,
-                nav,
-                node_type,
-                node_field: None,
-                pre_effects: vec![],
-                neg_fields,
-                post_effects: vec![],
-                successors: vec![exit],
-            }));
-            return entry;
-        }
-
-        // Determine Up navigation based on trailing anchor
-        let (has_trailing_anchor, trailing_strictness) = self.check_trailing_anchor(&items);
-
-        // With items: nav → items → Up → exit
-        let up_label = self.fresh_label();
-        let items_entry = self.compile_seq_items(&items, up_label, true);
-
-        // Emit Up instruction with appropriate strictness
-        let up_nav = if has_trailing_anchor {
-            if trailing_strictness {
-                Nav::UpExact(1)
-            } else {
-                Nav::UpSkipTrivia(1)
-            }
-        } else {
-            Nav::Up(1)
-        };
-        self.instructions.push(Instruction::Match(MatchIR {
-            label: up_label,
-            nav: up_nav,
-            node_type: None,
-            node_field: None,
-            pre_effects: vec![],
-            neg_fields: vec![],
-            post_effects: vec![],
-            successors: vec![exit],
-        }));
-
-        // Emit entry instruction into the node
-        self.instructions.push(Instruction::Match(MatchIR {
-            label: entry,
-            nav,
-            node_type,
-            node_field: None,
-            pre_effects: vec![],
-            neg_fields,
-            post_effects: vec![],
-            successors: vec![items_entry],
-        }));
-
-        entry
-    }
-
-    /// Compile an anonymous node: `"+"` or `_`.
-    ///
-    /// If `nav_override` is provided, uses that navigation instead of the default `Next`.
-    fn compile_anonymous_node_with_nav(&mut self, node: &ast::AnonymousNode, exit: Label, nav_override: Option<Nav>) -> Label {
-        let entry = self.fresh_label();
-        let nav = nav_override.unwrap_or(Nav::Next);
-
-        // Extract literal value (None for wildcard `_`)
-        let node_type = node.value().and_then(|token| {
-            let text = token.text();
-            self.resolve_anonymous_node_type(text)
-        });
-
-        self.instructions.push(Instruction::Match(MatchIR {
-            label: entry,
-            nav,
-            node_type,
-            node_field: None,
-            pre_effects: vec![],
-            neg_fields: vec![],
-            post_effects: vec![],
-            successors: vec![exit],
-        }));
-
-        entry
-    }
-
-    /// Compile an anonymous node: `"+"` or `_`.
-    fn compile_anonymous_node(&mut self, node: &ast::AnonymousNode, exit: Label) -> Label {
-        self.compile_anonymous_node_with_nav(node, exit, None)
-    }
-
-    /// Compile a reference: `(Expr)`.
-    fn compile_ref(&mut self, r: &ast::Ref, exit: Label) -> Label {
-        self.compile_ref_with_nav(r, exit, None)
-    }
-
-    /// Compile a reference with optional navigation override.
-    fn compile_ref_with_nav(&mut self, r: &ast::Ref, exit: Label, _nav_override: Option<Nav>) -> Label {
-        let Some(name_token) = r.name() else {
-            return exit;
-        };
-        let name = name_token.text();
-
-        let Some(sym) = self.type_ctx.get_def_id(self.interner, name) else {
-            return exit;
-        };
-
-        let Some(&target) = self.def_entries.get(&sym) else {
-            return exit;
-        };
-
-        // Check if this is a recursive reference
-        // Note: nav_override is not propagated here because the referenced
-        // definition has its own navigation semantics
-        if self.type_ctx.is_recursive(sym) {
-            // Emit Call instruction
-            let call_label = self.fresh_label();
-            let ref_id = self.fresh_ref_id();
-
-            self.instructions.push(Instruction::Call(CallIR {
-                label: call_label,
-                next: exit,
-                target,
-                ref_id,
-            }));
-
-            // Emit Return at the callee's exit
-            let return_label = self.fresh_label();
-            self.instructions.push(Instruction::Return(ReturnIR {
-                label: return_label,
-                ref_id,
-            }));
-
-            call_label
-        } else {
-            // Non-recursive: inline the body
-            // For simplicity, just jump to the target
-            target
-        }
-    }
-
-    /// Compile a sequence: `{a b c}`.
-    fn compile_seq(&mut self, seq: &ast::SeqExpr, exit: Label) -> Label {
-        self.compile_seq_with_nav(seq, exit, None)
-    }
-
-    /// Compile a sequence with optional navigation override for first item.
-    fn compile_seq_with_nav(&mut self, seq: &ast::SeqExpr, exit: Label, first_nav: Option<Nav>) -> Label {
-        let items: Vec<_> = seq.items().collect();
-        if items.is_empty() {
-            return exit;
-        }
-
-        // Determine if we're inside a node based on the navigation override
-        // Down variants mean we're descending into a node's children
-        let is_inside_node = matches!(first_nav, Some(Nav::Down | Nav::DownSkip | Nav::DownExact));
-
-        self.compile_seq_items_with_first_nav(&items, exit, is_inside_node, first_nav)
-    }
-
-    /// Compile an alternation: `[a b c]`.
-    fn compile_alt(&mut self, alt: &ast::AltExpr, exit: Label) -> Label {
-        self.compile_alt_with_nav(alt, exit, None)
-    }
-
-    /// Compile an alternation with optional navigation override for all branches.
-    fn compile_alt_with_nav(&mut self, alt: &ast::AltExpr, exit: Label, first_nav: Option<Nav>) -> Label {
-        let branches: Vec<_> = alt.branches().collect();
-        if branches.is_empty() {
-            return exit;
-        }
-
-        // Check if this is a tagged alternation (Enum type) and get type_id
-        let alt_expr = Expr::AltExpr(alt.clone());
-        let enum_type_id = self
-            .type_ctx
-            .get_term_info(&alt_expr)
-            .and_then(|info| info.flow.type_id());
-        let is_enum = enum_type_id
-            .and_then(|type_id| self.type_ctx.get_type(type_id))
-            .is_some_and(|shape| matches!(shape, TypeShape::Enum(_)));
-
-        // Get the enum's variant types for scope pushing
-        let variant_types: Vec<TypeId> = if is_enum {
-            enum_type_id
-                .and_then(|type_id| self.type_ctx.get_type(type_id))
-                .and_then(|shape| {
-                    if let TypeShape::Enum(variants) = shape {
-                        Some(variants.values().copied().collect())
-                    } else {
-                        None
-                    }
-                })
-                .unwrap_or_default()
-        } else {
-            vec![]
-        };
-
-        // Compile each branch, collecting entry labels
-        // Each branch gets the same nav override since any branch could match first
-        let mut successors = Vec::new();
-        for (variant_idx, branch) in branches.iter().enumerate() {
-            let Some(body) = branch.body() else {
-                continue;
-            };
-
-            if is_enum {
-                // Tagged branch: E(variant_ref) → body → EndE → exit
-                let ende_step = self.fresh_label();
-                self.instructions.push(Instruction::Match(MatchIR {
-                    label: ende_step,
-                    nav: Nav::Stay,
-                    node_type: None,
-                    node_field: None,
-                    pre_effects: vec![],
-                    neg_fields: vec![],
-                    post_effects: vec![EffectIR::simple(EffectOpcode::EndE, 0)],
-                    successors: vec![exit],
-                }));
-
-                // Compile body with variant's scope
-                let body_entry = if let Some(&payload_type_id) = variant_types.get(variant_idx) {
-                    self.with_scope(payload_type_id, |this| {
-                        this.compile_expr_with_nav(&body, ende_step, first_nav)
-                    })
-                } else {
-                    self.compile_expr_with_nav(&body, ende_step, first_nav)
-                };
-
-                // Create deferred member reference for the enum variant
-                let e_effect = if let Some(type_id) = enum_type_id {
-                    EffectIR::with_member(EffectOpcode::E, MemberRef::deferred(type_id, variant_idx as u16))
-                } else {
-                    EffectIR::simple(EffectOpcode::E, variant_idx)
-                };
-
-                let e_step = self.fresh_label();
-                self.instructions.push(Instruction::Match(MatchIR {
-                    label: e_step,
-                    nav: Nav::Stay,
-                    node_type: None,
-                    node_field: None,
-                    pre_effects: vec![e_effect],
-                    neg_fields: vec![],
-                    post_effects: vec![],
-                    successors: vec![body_entry],
-                }));
-
-                successors.push(e_step);
-            } else {
-                // Untagged branch: direct compilation
-                let branch_entry = self.compile_expr_with_nav(&body, exit, first_nav);
-                successors.push(branch_entry);
-            }
-        }
-
-        if successors.is_empty() {
-            return exit;
-        }
-        if successors.len() == 1 {
-            return successors[0];
-        }
-
-        // Emit epsilon branch to choose among alternatives
-        let entry = self.fresh_label();
-        self.emit_epsilon(entry, successors);
-        entry
-    }
-
-    /// Compile a quantified expression: `a?`, `a*`, `a+`.
-    fn compile_quantified(&mut self, quant: &ast::QuantifiedExpr, exit: Label) -> Label {
-        self.compile_quantified_with_nav(quant, exit, None)
-    }
-
-    /// Compile a quantified expression with optional navigation override.
-    fn compile_quantified_with_nav(
-        &mut self,
-        quant: &ast::QuantifiedExpr,
-        exit: Label,
-        nav_override: Option<Nav>,
-    ) -> Label {
-        let Some(inner) = quant.inner() else {
-            return exit;
-        };
-
-        let Some(op) = quant.operator() else {
-            return self.compile_expr_with_nav(&inner, exit, nav_override);
-        };
-
-        let is_plus = matches!(op.kind(), SyntaxKind::Plus | SyntaxKind::PlusQuestion);
-        let is_star = matches!(op.kind(), SyntaxKind::Star | SyntaxKind::StarQuestion);
-        let is_greedy = matches!(
-            op.kind(),
-            SyntaxKind::Question | SyntaxKind::Star | SyntaxKind::Plus
-        );
-
-        if is_plus {
-            // +: body → loop_entry → [body, exit]
-            // First iteration uses nav_override, subsequent use default
-            let loop_entry = self.fresh_label();
-            let first_body_entry = self.compile_expr_with_nav(&inner, loop_entry, nav_override);
-            let repeat_body_entry = self.compile_expr(&inner, loop_entry);
-
-            let successors = if is_greedy {
-                vec![repeat_body_entry, exit]
-            } else {
-                vec![exit, repeat_body_entry]
-            };
-            self.emit_epsilon(loop_entry, successors);
-
-            first_body_entry
-        } else if is_star {
-            // *: loop_entry → [body → loop_entry, exit]
-            // First iteration uses nav_override, subsequent use default
-            let loop_entry = self.fresh_label();
-            let first_body_entry = self.compile_expr_with_nav(&inner, loop_entry, nav_override);
-            let repeat_body_entry = self.compile_expr(&inner, loop_entry);
-
-            // Entry point branches: first iteration or exit
-            let entry = self.fresh_label();
-            let successors = if is_greedy {
-                vec![first_body_entry, exit]
-            } else {
-                vec![exit, first_body_entry]
-            };
-            self.emit_epsilon(entry, successors);
-
-            // Loop point branches: repeat iteration or exit
-            let loop_successors = if is_greedy {
-                vec![repeat_body_entry, exit]
-            } else {
-                vec![exit, repeat_body_entry]
-            };
-            self.emit_epsilon(loop_entry, loop_successors);
-
-            entry
-        } else {
-            // ?: branch to body or exit
-            let body_entry = self.compile_expr_with_nav(&inner, exit, nav_override);
-            let entry = self.fresh_label();
-
-            let successors = if is_greedy {
-                vec![body_entry, exit]
-            } else {
-                vec![exit, body_entry]
-            };
-            self.emit_epsilon(entry, successors);
-
-            entry
-        }
-    }
-
-    /// Compile a field constraint: `name: pattern`.
-    fn compile_field(&mut self, field: &ast::FieldExpr, exit: Label) -> Label {
-        self.compile_field_with_nav(field, exit, None)
-    }
-
-    /// Compile a field constraint with optional navigation override.
-    fn compile_field_with_nav(
-        &mut self,
-        field: &ast::FieldExpr,
-        exit: Label,
-        nav_override: Option<Nav>,
-    ) -> Label {
-        let Some(value) = field.value() else {
-            return exit;
-        };
-
-        let node_field = self.resolve_field(field);
-
-        // Compile the value pattern with nav override
-        let value_entry = self.compile_expr_with_nav(&value, exit, nav_override);
-
-        // If we have a field constraint, wrap with a field-checking Match
-        if node_field.is_some() {
-            let entry = self.fresh_label();
-            self.instructions.push(Instruction::Match(MatchIR {
-                label: entry,
-                nav: Nav::Stay, // Check field without moving
-                node_type: None,
-                node_field,
-                pre_effects: vec![],
-                neg_fields: vec![],
-                post_effects: vec![],
-                successors: vec![value_entry],
-            }));
-            return entry;
-        }
-
-        value_entry
-    }
-
-    /// Compile a captured expression: `@name` or `pattern @name`.
-    fn compile_captured(&mut self, cap: &ast::CapturedExpr, exit: Label) -> Label {
-        self.compile_captured_with_nav(cap, exit, None)
-    }
-
-    /// Compile a captured expression with optional navigation override.
-    ///
-    /// Effects are emitted AFTER the inner pattern matches, not before.
-    /// Flow depends on captured type:
-    /// - Scalar: inner_pattern → [Node/Text, Set] → exit
-    /// - Struct: S → inner_pattern → [EndS, Node/Text, Set] → exit
-    /// - Array:  A → quantifier (with Push) → [EndA, Node/Text, Set] → exit
-    fn compile_captured_with_nav(
-        &mut self,
-        cap: &ast::CapturedExpr,
-        exit: Label,
-        nav_override: Option<Nav>,
-    ) -> Label {
-        // Determine effects based on capture type
-        let is_text = cap.type_annotation().is_some_and(|t| {
-            t.name().map(|n| n.text() == "string").unwrap_or(false)
-        });
-
-        // Query type system to determine structural effects needed
-        // - S/EndS: Check if INNER's flow is Bubble (has fields to collect)
-        // - A/Push/EndA: Check if INNER's arity is Many (star/plus quantifier)
-        let inner = cap.inner();
-        let inner_info = inner.as_ref().and_then(|inner| self.type_ctx.get_term_info(inner));
-        let inner_is_bubble = inner_info.as_ref().map(|info| info.flow.is_bubble()).unwrap_or(false);
-
-        // Determine which type to push for scope:
-        // - If inner creates scope (sequence/alternation): use inner's type
-        //   because the capture wraps it in another struct level
-        // - If inner doesn't create scope (named node/ref): use capture's type
-        //   because fields merge into one struct
-        let inner_creates_scope = inner.as_ref().map(Self::inner_creates_scope).unwrap_or(false);
-        let scope_type_id = if inner_creates_scope {
-            // Use inner's type (e.g., for `{a b} @row`, inner's type has a, b fields)
-            inner_info.as_ref().and_then(|info| info.flow.type_id())
-        } else {
-            // Use capture's type (e.g., for `(x @a) @b`, capture's type has a, b merged)
-            let cap_expr = Expr::CapturedExpr(cap.clone());
-            self.type_ctx
-                .get_term_info(&cap_expr)
-                .and_then(|info| info.flow.type_id())
-        };
-
-        // Build capture effects: Node/Text followed by Set(member_ref)
-        // We compute this after determining scope_type_id so we can use it for member lookup
-        let mut capture_effects: Vec<EffectIR> = Vec::with_capacity(2);
-
-        let capture_effect = if is_text {
-            EffectIR::simple(EffectOpcode::Text, 0)
-        } else {
-            EffectIR::simple(EffectOpcode::Node, 0)
-        };
-        capture_effects.push(capture_effect);
-
-        // Add Set effect if we can resolve the member reference
-        // Bubble captures: look up in scope_type_id (the struct being collected)
-        // Non-bubble captures: look up in current scope stack (parent struct)
-        if let Some(name_token) = cap.name() {
-            let member_ref = if inner_is_bubble {
-                scope_type_id.and_then(|t| self.lookup_member(name_token.text(), t))
-            } else {
-                self.lookup_member_in_scope(name_token.text())
-            };
-            if let Some(member_ref) = member_ref {
-                capture_effects.push(EffectIR::with_member(EffectOpcode::Set, member_ref));
-            }
-        }
-
-        // Check for Many arity (star/plus) - use type system if available, else syntactic check
-        let inner_is_many = inner_info
-            .map(|info| matches!(info.arity, Arity::Many))
-            .unwrap_or_else(|| {
-                // Fallback: check syntactically for star/plus
-                inner.as_ref().is_some_and(|inner| {
-                    if let Expr::QuantifiedExpr(q) = inner {
-                        q.operator().is_some_and(|op| {
-                            matches!(
-                                op.kind(),
-                                SyntaxKind::Star | SyntaxKind::StarQuestion | SyntaxKind::Plus | SyntaxKind::PlusQuestion
-                            )
-                        })
-                    } else {
-                        false
-                    }
-                })
-            });
-
-        if let Some(inner) = cap.inner() {
-            // Pattern with capture: effects fire AFTER inner matches
-            let effect_label = self.fresh_label();
-
-            if inner_is_bubble {
-                // Struct scope: S → inner → EndS + capture_effects → exit
-                let mut post_effects = vec![EffectIR::simple(EffectOpcode::EndS, 0)];
-                post_effects.extend(capture_effects);
-
-                self.instructions.push(Instruction::Match(MatchIR {
-                    label: effect_label,
-                    nav: Nav::Stay,
-                    node_type: None,
-                    node_field: None,
-                    pre_effects: vec![],
-                    neg_fields: vec![],
-                    post_effects,
-                    successors: vec![exit],
-                }));
-
-                // Compile inner with scope for captures
-                let inner_entry = if let Some(type_id) = scope_type_id {
-                    self.with_scope(type_id, |this| {
-                        this.compile_expr_with_nav(&inner, effect_label, nav_override)
-                    })
-                } else {
-                    self.compile_expr_with_nav(&inner, effect_label, nav_override)
-                };
-
-                // S step before inner
-                let s_step = self.fresh_label();
-                self.instructions.push(Instruction::Match(MatchIR {
-                    label: s_step,
-                    nav: Nav::Stay,
-                    node_type: None,
-                    node_field: None,
-                    pre_effects: vec![EffectIR::simple(EffectOpcode::S, 0)],
-                    neg_fields: vec![],
-                    post_effects: vec![],
-                    successors: vec![inner_entry],
-                }));
-
-                s_step
-            } else if inner_is_many {
-                // Array: A → quantifier (with Push) → EndA + capture_effects → exit
-                let mut post_effects = vec![EffectIR::simple(EffectOpcode::EndA, 0)];
-                post_effects.extend(capture_effects);
-
-                self.instructions.push(Instruction::Match(MatchIR {
-                    label: effect_label,
-                    nav: Nav::Stay,
-                    node_type: None,
-                    node_field: None,
-                    pre_effects: vec![],
-                    neg_fields: vec![],
-                    post_effects,
-                    successors: vec![exit],
-                }));
-
-                // Compile quantifier with Push effects
-                let inner_entry = if let Expr::QuantifiedExpr(quant) = &inner {
-                    self.compile_quantified_for_array(quant, effect_label, nav_override)
-                } else {
-                    self.compile_expr_with_nav(&inner, effect_label, nav_override)
-                };
-
-                // A step before inner
-                let a_step = self.fresh_label();
-                self.instructions.push(Instruction::Match(MatchIR {
-                    label: a_step,
-                    nav: Nav::Stay,
-                    node_type: None,
-                    node_field: None,
-                    pre_effects: vec![EffectIR::simple(EffectOpcode::A, 0)],
-                    neg_fields: vec![],
-                    post_effects: vec![],
-                    successors: vec![inner_entry],
-                }));
-
-                a_step
-            } else {
-                // Scalar: just capture effects
-                self.instructions.push(Instruction::Match(MatchIR {
-                    label: effect_label,
-                    nav: Nav::Stay,
-                    node_type: None,
-                    node_field: None,
-                    pre_effects: vec![],
-                    neg_fields: vec![],
-                    post_effects: capture_effects,
-                    successors: vec![exit],
-                }));
-
-                self.compile_expr_with_nav(&inner, effect_label, nav_override)
-            }
-        } else {
-            // Bare capture: just emit effects at current position
-            let entry = self.fresh_label();
-            self.instructions.push(Instruction::Match(MatchIR {
-                label: entry,
-                nav: Nav::Stay,
-                node_type: None,
-                node_field: None,
-                pre_effects: vec![],
-                neg_fields: vec![],
-                post_effects: capture_effects,
-                successors: vec![exit],
-            }));
-            entry
-        }
-    }
-
-    /// Compile a quantified expression for array capture, adding Push after each iteration.
-    fn compile_quantified_for_array(
-        &mut self,
-        quant: &ast::QuantifiedExpr,
-        exit: Label,
-        nav_override: Option<Nav>,
-    ) -> Label {
-        let Some(inner) = quant.inner() else {
-            return exit;
-        };
-
-        let Some(op) = quant.operator() else {
-            return self.compile_expr_with_nav(&inner, exit, nav_override);
-        };
-
-        let is_plus = matches!(op.kind(), SyntaxKind::Plus | SyntaxKind::PlusQuestion);
-        let is_star = matches!(op.kind(), SyntaxKind::Star | SyntaxKind::StarQuestion);
-        let is_greedy = matches!(
-            op.kind(),
-            SyntaxKind::Question | SyntaxKind::Star | SyntaxKind::Plus
-        );
-
-        // Get the row struct type for scoping: inner expression's type
-        // This is the struct type that captures inside the loop body belong to
-        let row_type_id = self.type_ctx.get_term_info(&inner).and_then(|info| info.flow.type_id());
-
-        // Push step: fires after each iteration completes
-        let push_step = self.fresh_label();
-        self.instructions.push(Instruction::Match(MatchIR {
-            label: push_step,
-            nav: Nav::Stay,
-            node_type: None,
-            node_field: None,
-            pre_effects: vec![],
-            neg_fields: vec![],
-            post_effects: vec![EffectIR::simple(EffectOpcode::Push, 0)],
-            successors: vec![], // Will be set below
-        }));
-        let push_idx = self.instructions.len() - 1;
-
-        // Helper to compile with optional scope
-        let compile_with_row_scope = |this: &mut Self, exit: Label, nav: Option<Nav>| {
-            if let Some(type_id) = row_type_id {
-                this.with_scope(type_id, |t| t.compile_expr_with_nav(&inner, exit, nav))
-            } else {
-                this.compile_expr_with_nav(&inner, exit, nav)
-            }
-        };
-
-        if is_plus {
-            // +: first_body → push → loop_entry → [repeat_body → push, exit]
-            let loop_entry = self.fresh_label();
-
-            let first_body_entry = compile_with_row_scope(self, push_step, nav_override);
-            let repeat_body_entry = compile_with_row_scope(self, push_step, None);
-
-            // Push leads to loop_entry
-            if let Instruction::Match(ref mut m) = self.instructions[push_idx] {
-                m.successors = vec![loop_entry];
-            }
-
-            // Loop chooses between repeat and exit
-            let successors = if is_greedy {
-                vec![repeat_body_entry, exit]
-            } else {
-                vec![exit, repeat_body_entry]
-            };
-            self.emit_epsilon(loop_entry, successors);
-
-            first_body_entry
-        } else if is_star {
-            // *: entry → [first_body → push → loop_entry → [repeat_body → push, exit], exit]
-            let loop_entry = self.fresh_label();
-
-            let first_body_entry = compile_with_row_scope(self, push_step, nav_override);
-            let repeat_body_entry = compile_with_row_scope(self, push_step, None);
-
-            // Push leads to loop_entry
-            if let Instruction::Match(ref mut m) = self.instructions[push_idx] {
-                m.successors = vec![loop_entry];
-            }
-
-            // Entry point branches: first iteration or exit
-            let entry = self.fresh_label();
-            let successors = if is_greedy {
-                vec![first_body_entry, exit]
-            } else {
-                vec![exit, first_body_entry]
-            };
-            self.emit_epsilon(entry, successors);
-
-            // Loop point branches: repeat iteration or exit
-            let loop_successors = if is_greedy {
-                vec![repeat_body_entry, exit]
-            } else {
-                vec![exit, repeat_body_entry]
-            };
-            self.emit_epsilon(loop_entry, loop_successors);
-
-            entry
-        } else {
-            // ?: branch to body or exit (no Push needed for optional)
-            let body_entry = compile_with_row_scope(self, exit, nav_override);
-
-            let entry = self.fresh_label();
-
-            let successors = if is_greedy {
-                vec![body_entry, exit]
-            } else {
-                vec![exit, body_entry]
-            };
-            self.emit_epsilon(entry, successors);
-
-            entry
-        }
-    }
-
-    /// Emit an epsilon transition (no node interaction).
-    fn emit_epsilon(&mut self, label: Label, successors: Vec<Label>) {
-        self.instructions.push(Instruction::Match(MatchIR {
-            label,
-            nav: Nav::Stay,
-            node_type: None,
-            node_field: None,
-            pre_effects: vec![],
-            neg_fields: vec![],
-            post_effects: vec![],
-            successors,
-        }));
-    }
-
-    /// Resolve an anonymous node's literal text to its node type ID.
-    ///
-    /// In linked mode, returns the grammar NodeTypeId for the literal.
-    /// In unlinked mode, returns the StringId of the literal text.
-    fn resolve_anonymous_node_type(&mut self, text: &str) -> Option<NonZeroU16> {
-        if let Some(ids) = self.node_type_ids {
-            // Linked mode: resolve to NodeTypeId from grammar
-            for (&sym, &id) in ids {
-                if self.interner.resolve(sym) == text {
-                    return NonZeroU16::new(id.get());
-                }
-            }
-            // If not found in grammar, treat as no constraint
-            None
-        } else {
-            // Unlinked mode: store StringId referencing the literal text
-            let string_id = self.strings.intern_str(text);
-            NonZeroU16::new(string_id.0)
-        }
-    }
-
-    /// Resolve a NamedNode to its node type ID.
-    ///
-    /// In linked mode, returns the grammar NodeTypeId.
-    /// In unlinked mode, returns the StringId of the type name.
-    fn resolve_node_type(&mut self, node: &ast::NamedNode) -> Option<NonZeroU16> {
-        // For wildcard (_), no constraint
-        if node.is_any() {
-            return None;
-        }
-
-        let type_token = node.node_type()?;
-        let type_name = type_token.text();
-
-        if let Some(ids) = self.node_type_ids {
-            // Linked mode: resolve to NodeTypeId from grammar
-            for (&sym, &id) in ids {
-                if self.interner.resolve(sym) == type_name {
-                    return NonZeroU16::new(id.get());
-                }
-            }
-            // If not found in grammar, treat as no constraint (linked mode)
-            None
-        } else {
-            // Unlinked mode: store StringId referencing the type name
-            let string_id = self.strings.intern_str(type_name);
-            NonZeroU16::new(string_id.0)
-        }
-    }
-
-    /// Resolve a field expression to its field ID.
-    ///
-    /// In linked mode, returns the grammar NodeFieldId.
-    /// In unlinked mode, returns the StringId of the field name.
-    fn resolve_field(&mut self, field: &ast::FieldExpr) -> Option<NonZeroU16> {
-        let name_token = field.name()?;
-        let field_name = name_token.text();
-        self.resolve_field_by_name(field_name)
-    }
-
-    /// Resolve a field name to its field ID.
-    ///
-    /// In linked mode, returns the grammar NodeFieldId.
-    /// In unlinked mode, returns the StringId of the field name.
-    fn resolve_field_by_name(&mut self, field_name: &str) -> Option<NonZeroU16> {
-        if let Some(ids) = self.node_field_ids {
-            // Linked mode: resolve to NodeFieldId from grammar
-            for (&sym, &id) in ids {
-                if self.interner.resolve(sym) == field_name {
-                    return NonZeroU16::new(id.get());
-                }
-            }
-            // If not found in grammar, treat as no constraint (linked mode)
-            None
-        } else {
-            // Unlinked mode: store StringId referencing the field name
-            let string_id = self.strings.intern_str(field_name);
-            NonZeroU16::new(string_id.0)
-        }
-    }
-
-    /// Collect negated fields from a NamedNode.
-    fn collect_neg_fields(&mut self, node: &ast::NamedNode) -> Vec<u16> {
-        node.as_cst()
-            .children()
-            .filter_map(ast::NegatedField::cast)
-            .filter_map(|nf| {
-                let name = nf.name()?;
-                self.resolve_field_by_name(name.text())
-            })
-            .map(|id| id.get())
-            .collect()
-    }
-
-    /// Determines if an expression creates a scope boundary when captured.
-    /// Sequences and alternations create scopes; named nodes/refs don't.
-    fn inner_creates_scope(inner: &Expr) -> bool {
-        match inner {
-            Expr::SeqExpr(_) | Expr::AltExpr(_) => true,
-            Expr::QuantifiedExpr(q) => {
-                q.inner().is_some_and(|i| Self::inner_creates_scope(&i))
-            }
-            _ => false,
-        }
-    }
-
-    /// Execute a closure with a scope pushed, automatically popping afterward.
-    fn with_scope<T>(&mut self, type_id: TypeId, f: impl FnOnce(&mut Self) -> T) -> T {
-        self.scope_stack.push(StructScope(type_id));
-        let result = f(self);
-        self.scope_stack.pop();
-        result
-    }
-
-    /// Look up a capture name in a type, returning a deferred member reference.
-    fn lookup_member(&self, capture_name: &str, type_id: TypeId) -> Option<MemberRef> {
-        let fields = self.type_ctx.get_struct_fields(type_id)?;
-        for (relative_index, (&sym, _)) in fields.iter().enumerate() {
-            if self.interner.resolve(sym) == capture_name {
-                return Some(MemberRef::deferred(type_id, relative_index as u16));
-            }
-        }
-        None
-    }
-
-    /// Look up a capture name in the current scope stack.
-    fn lookup_member_in_scope(&self, capture_name: &str) -> Option<MemberRef> {
-        let StructScope(type_id) = *self.scope_stack.last()?;
-        self.lookup_member(capture_name, type_id)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::query::QueryBuilder;
-
-    #[test]
-    fn compile_simple_named_node() {
-        let query = QueryBuilder::one_liner("Test = (identifier)")
-            .parse()
-            .unwrap()
-            .analyze();
-
-        let mut strings = StringTableBuilder::new();
-        let result = Compiler::compile(
-            query.interner(),
-            query.type_context(),
-            &query.symbol_table,
-            &mut strings,
-            None,
-            None,
-        )
-        .unwrap();
-
-        // Should have at least one instruction
-        assert!(!result.instructions.is_empty());
-        // Should have one entrypoint
-        assert_eq!(result.def_entries.len(), 1);
-    }
-
-    #[test]
-    fn compile_alternation() {
-        let query = QueryBuilder::one_liner("Test = [(identifier) (number)]")
-            .parse()
-            .unwrap()
-            .analyze();
-
-        let mut strings = StringTableBuilder::new();
-        let result = Compiler::compile(
-            query.interner(),
-            query.type_context(),
-            &query.symbol_table,
-            &mut strings,
-            None,
-            None,
-        )
-        .unwrap();
-
-        assert!(!result.instructions.is_empty());
-    }
-
-    #[test]
-    fn compile_sequence() {
-        let query = QueryBuilder::one_liner("Test = {(comment) (function)}")
-            .parse()
-            .unwrap()
-            .analyze();
-
-        let mut strings = StringTableBuilder::new();
-        let result = Compiler::compile(
-            query.interner(),
-            query.type_context(),
-            &query.symbol_table,
-            &mut strings,
-            None,
-            None,
-        )
-        .unwrap();
-
-        assert!(!result.instructions.is_empty());
-    }
-
-    #[test]
-    fn compile_quantified() {
-        let query = QueryBuilder::one_liner("Test = (identifier)*")
-            .parse()
-            .unwrap()
-            .analyze();
-
-        let mut strings = StringTableBuilder::new();
-        let result = Compiler::compile(
-            query.interner(),
-            query.type_context(),
-            &query.symbol_table,
-            &mut strings,
-            None,
-            None,
-        )
-        .unwrap();
-
-        assert!(!result.instructions.is_empty());
-    }
-
-    #[test]
-    fn compile_capture() {
-        let query = QueryBuilder::one_liner("Test = (identifier) @id")
-            .parse()
-            .unwrap()
-            .analyze();
-
-        let mut strings = StringTableBuilder::new();
-        let result = Compiler::compile(
-            query.interner(),
-            query.type_context(),
-            &query.symbol_table,
-            &mut strings,
-            None,
-            None,
-        )
-        .unwrap();
-
-        assert!(!result.instructions.is_empty());
-    }
-
-    #[test]
-    fn compile_nested() {
-        let query = QueryBuilder::one_liner("Test = (call_expression function: (identifier) @fn)")
-            .parse()
-            .unwrap()
-            .analyze();
-
-        let mut strings = StringTableBuilder::new();
-        let result = Compiler::compile(
-            query.interner(),
-            query.type_context(),
-            &query.symbol_table,
-            &mut strings,
-            None,
-            None,
-        )
-        .unwrap();
-
-        assert!(!result.instructions.is_empty());
-    }
-}
diff --git a/crates/plotnik-lib/src/query/compile/capture.rs b/crates/plotnik-lib/src/query/compile/capture.rs
new file mode 100644
index 00000000..94432efa
--- /dev/null
+++ b/crates/plotnik-lib/src/query/compile/capture.rs
@@ -0,0 +1,162 @@
+//! Capture effects handling for query compilation.
+//!
+//! Manages the construction and propagation of capture effects (Node/Text + Set)
+//! through the compilation pipeline.
+
+use std::collections::HashSet;
+
+use crate::bytecode::ir::EffectIR;
+use crate::bytecode::EffectOpcode;
+use crate::parser::ast::{self, Expr};
+use crate::query::type_check::{TypeContext, TypeId, TypeShape};
+
+use super::navigation::{inner_creates_scope, is_star_or_plus_quantifier};
+use super::Compiler;
+
+/// Capture effects to attach to the innermost match instruction.
+///
+/// Instead of emitting a separate epsilon transition for capture effects,
+/// these effects are propagated through the compilation chain and attached
+/// directly to the match instruction that captures the node.
+#[derive(Clone, Default)]
+pub struct CaptureEffects {
+    /// Effects to place as post_effects on the matching instruction.
+    /// Typically: [Node/Text, Set(member)] or [Node/Text, Push]
+    pub post: Vec<EffectIR>,
+}
+
+impl Compiler<'_> {
+    /// Build capture effects (Node/Text + Set) based on capture type.
+    pub(super) fn build_capture_effects(
+        &self,
+        cap: &ast::CapturedExpr,
+        inner: Option<&Expr>,
+    ) -> Vec<EffectIR> {
+        let mut effects = Vec::with_capacity(2);
+
+        // Skip Node/Text when the value comes from somewhere other than matched_node:
+        // 1. Refs returning structured types (Call leaves result pending)
+        // 2. Scope-creating expressions (Seq/Alt) producing structured types (EndObj/EndEnum)
+        // 3. Array captures (EndArr produces value)
+        let is_structured_ref = inner.is_some_and(|i| self.is_ref_returning_structured(i));
+        let is_array = is_star_or_plus_quantifier(inner);
+
+        // Check if inner is a scope-creating expression (SeqExpr/AltExpr) that produces
+        // a structured type (Struct/Enum). Named nodes with bubble captures don't count -
+        // they still need Node because we're capturing the matched node, not the struct.
+        let creates_structured_scope = inner.is_some_and(|i| {
+            inner_creates_scope(i)
+                && self
+                    .type_ctx
+                    .get_term_info(i)
+                    .and_then(|info| info.flow.type_id())
+                    .and_then(|id| self.type_ctx.get_type(id))
+                    .is_some_and(|shape| matches!(shape, TypeShape::Struct(_) | TypeShape::Enum(_)))
+        });
+
+        if !is_structured_ref && !creates_structured_scope && !is_array {
+            let is_text = cap.type_annotation().is_some_and(|t| {
+                t.name().is_some_and(|n| n.text() == "string")
+            });
+            let opcode = if is_text { EffectOpcode::Text } else { EffectOpcode::Node };
+            effects.push(EffectIR::simple(opcode, 0));
+        }
+
+        // Add Set effect if we have a capture name.
+        // Always look up in the current scope - bubble captures don't create new scopes,
+        // so all fields (including nested bubble captures) reference the same root struct.
+        if let Some(name_token) = cap.name() {
+            let capture_name = name_token.text();
+            let member_ref = self.lookup_member_in_scope(capture_name);
+            if let Some(member_ref) = member_ref {
+                effects.push(EffectIR::with_member(EffectOpcode::Set, member_ref));
+            }
+        }
+
+        effects
+    }
+
+    /// Check if expr is (or wraps) a ref returning a structured type.
+    ///
+    /// For such refs, we skip the Node effect in captures - the Call leaves
+    /// the structured result (Enum/Struct/Array) pending for Set to consume.
+    pub(super) fn is_ref_returning_structured(&self, expr: &Expr) -> bool {
+        match expr {
+            Expr::Ref(r) => self.ref_returns_structured(r),
+            Expr::QuantifiedExpr(q) => q
+                .inner()
+                .is_some_and(|i| self.is_ref_returning_structured(&i)),
+            Expr::CapturedExpr(c) => c
+                .inner()
+                .is_some_and(|i| self.is_ref_returning_structured(&i)),
+            Expr::FieldExpr(f) => f
+                .value()
+                .is_some_and(|v| self.is_ref_returning_structured(&v)),
+            _ => false,
+        }
+    }
+
+    /// Check if a Ref points to a definition returning a structured type.
+    ///
+    /// All refs now use Call/Return. If the definition returns a structured type
+    /// (Enum/Struct/Array), Return leaves that result pending for Set to consume.
+    /// In this case, we skip emitting Node/Text effects in captures.
+    fn ref_returns_structured(&self, r: &ast::Ref) -> bool {
+        if let Some(name) = r.name()
+            && let Some(def_id) = self.type_ctx.get_def_id(self.interner, name.text())
+            && let Some(def_type) = self.type_ctx.get_def_type(def_id)
+            && let Some(shape) = self.type_ctx.get_type(def_type)
+        {
+            matches!(shape, TypeShape::Struct(_) | TypeShape::Enum(_) | TypeShape::Array { .. })
+        } else {
+            false
+        }
+    }
+
+    /// Collect all capture names from an expression recursively.
+    pub(super) fn collect_captures(expr: &Expr) -> HashSet<String> {
+        fn collect(expr: &Expr, names: &mut HashSet<String>) {
+            if let Expr::CapturedExpr(cap) = expr
+                && let Some(name) = cap.name()
+            {
+                names.insert(name.text().to_string());
+            }
+            for child in expr.children() {
+                collect(&child, names);
+            }
+        }
+        let mut names = HashSet::new();
+        collect(expr, &mut names);
+        names
+    }
+}
+
+/// Check if inner needs struct wrapper for array iterations.
+///
+/// Returns true when inner is a scope-creating expression (sequence/alternation)
+/// that produces an untagged struct (not an enum). Enums use Enum/EndEnum instead.
+pub fn check_needs_struct_wrapper(
+    inner: &Expr,
+    type_ctx: &TypeContext,
+) -> bool {
+    let inner_info = type_ctx.get_term_info(inner);
+    let inner_creates_scope = inner_creates_scope(inner);
+    let inner_is_untagged_bubble = inner_info.as_ref().is_some_and(|info| {
+        if !info.flow.is_bubble() {
+            return false;
+        }
+        let Some(type_id) = info.flow.type_id() else {
+            return false;
+        };
+        let Some(shape) = type_ctx.get_type(type_id) else {
+            return false;
+        };
+        matches!(shape, TypeShape::Struct(_))
+    });
+    inner_is_untagged_bubble && inner_creates_scope
+}
+
+/// Get row type ID for array element scoping.
+pub fn get_row_type_id(inner: &Expr, type_ctx: &TypeContext) -> Option<TypeId> {
+    type_ctx.get_term_info(inner).and_then(|info| info.flow.type_id())
+}
diff --git a/crates/plotnik-lib/src/query/compile/expressions.rs b/crates/plotnik-lib/src/query/compile/expressions.rs
new file mode 100644
index 00000000..2d23b46f
--- /dev/null
+++ b/crates/plotnik-lib/src/query/compile/expressions.rs
@@ -0,0 +1,429 @@
+//! Expression compilation for leaf and wrapper patterns.
+//!
+//! Handles compilation of:
+//! - Named nodes: `(identifier)`, `(call_expression ...)`
+//! - Anonymous nodes: `"+"`, `_`
+//! - References: `(Expr)` (calls to other definitions)
+//! - Field constraints: `name: pattern`
+//! - Captured expressions: `@name`, `pattern @name`
+
+use std::num::NonZeroU16;
+
+use crate::bytecode::ir::{CallIR, Instruction, Label, MatchIR};
+use crate::bytecode::Nav;
+use crate::parser::ast::{self, Expr};
+use crate::query::type_check::Arity;
+
+use super::capture::CaptureEffects;
+use super::navigation::{check_trailing_anchor, inner_creates_scope, is_skippable_quantifier, is_star_or_plus_quantifier};
+use super::Compiler;
+
+impl Compiler<'_> {
+    /// Compile a named node: `(identifier)` or `(call_expression arg: ...)`.
+    pub(super) fn compile_named_node(&mut self, node: &ast::NamedNode, exit: Label) -> Label {
+        self.compile_named_node_inner(node, exit, None, CaptureEffects::default())
+    }
+
+    /// Compile a named node with capture effects.
+    pub(super) fn compile_named_node_inner(
+        &mut self,
+        node: &ast::NamedNode,
+        exit: Label,
+        nav_override: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        let entry = self.fresh_label();
+        let node_type = self.resolve_node_type(node);
+        let nav = nav_override.unwrap_or(Nav::Stay);
+
+        // Collect items and negated fields
+        let items: Vec<_> = node.items().collect();
+        let neg_fields = self.collect_neg_fields(node);
+
+        // If no items, just match and exit (capture effects go here)
+        if items.is_empty() {
+            self.instructions.push(Instruction::Match(MatchIR {
+                label: entry,
+                nav,
+                node_type,
+                node_field: None,
+                pre_effects: vec![],
+                neg_fields,
+                post_effects: capture.post,
+                successors: vec![exit],
+            }));
+            return entry;
+        }
+
+        // Determine Up navigation based on trailing anchor
+        let (has_trailing_anchor, trailing_strictness) = check_trailing_anchor(&items);
+
+        // Emit Up instruction with appropriate strictness
+        let up_nav = if has_trailing_anchor {
+            if trailing_strictness {
+                Nav::UpExact(1)
+            } else {
+                Nav::UpSkipTrivia(1)
+            }
+        } else {
+            Nav::Up(1)
+        };
+
+        // Check if first item is skippable - its skip path should bypass the Up.
+        // When a zero-match quantifier (? or *) is the first child with Down navigation,
+        // the skip path never descends, so executing Up would ascend too far.
+        let first_is_skippable = items
+            .first()
+            .and_then(|i| i.as_expr())
+            .is_some_and(is_skippable_quantifier);
+
+        // With items: nav → items → Up → exit
+        // If first item is skippable: skip path → exit (bypass Up), match path → Up → exit
+        let up_label = self.fresh_label();
+        let skip_exit = first_is_skippable.then_some(exit);
+        let items_entry =
+            self.compile_seq_items_inner(&items, up_label, true, None, CaptureEffects::default(), skip_exit);
+
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: up_label,
+            nav: up_nav,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: vec![],
+            successors: vec![exit],
+        }));
+
+        // Emit entry instruction into the node (capture effects go here at match time)
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: entry,
+            nav,
+            node_type,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields,
+            post_effects: capture.post,
+            successors: vec![items_entry],
+        }));
+
+        entry
+    }
+
+    /// Compile an anonymous node: `"+"` or `_`.
+    pub(super) fn compile_anonymous_node(&mut self, node: &ast::AnonymousNode, exit: Label) -> Label {
+        self.compile_anonymous_node_inner(node, exit, None, CaptureEffects::default())
+    }
+
+    /// Compile an anonymous node with capture effects.
+    pub(super) fn compile_anonymous_node_inner(
+        &mut self,
+        node: &ast::AnonymousNode,
+        exit: Label,
+        nav_override: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        let entry = self.fresh_label();
+        let nav = nav_override.unwrap_or(Nav::Next);
+
+        // Extract literal value (None for wildcard `_`)
+        let node_type = node.value().and_then(|token| {
+            let text = token.text();
+            self.resolve_anonymous_node_type(text)
+        });
+
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: entry,
+            nav,
+            node_type,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: capture.post,
+            successors: vec![exit],
+        }));
+
+        entry
+    }
+
+    /// Compile a reference: `(Expr)`.
+    pub(super) fn compile_ref(&mut self, r: &ast::Ref, exit: Label) -> Label {
+        self.compile_ref_inner(r, exit, None, None, CaptureEffects::default())
+    }
+
+    /// Compile a reference with capture effects.
+    ///
+    /// For Call instructions, capture effects are placed in an epsilon after the call,
+    /// since the call returns a structured value that the effects operate on.
+    pub(super) fn compile_ref_inner(
+        &mut self,
+        r: &ast::Ref,
+        exit: Label,
+        nav_override: Option<Nav>,
+        field_override: Option<NonZeroU16>,
+        capture: CaptureEffects,
+    ) -> Label {
+        let Some(name_token) = r.name() else {
+            return exit;
+        };
+        let name = name_token.text();
+
+        let Some(def_id) = self.type_ctx.get_def_id(self.interner, name) else {
+            return exit;
+        };
+
+        let Some(&target) = self.def_entries.get(&def_id) else {
+            return exit;
+        };
+
+        // Determine return address: if capture effects present, emit epsilon for them
+        let return_addr = if capture.post.is_empty() {
+            exit
+        } else {
+            let effects_label = self.fresh_label();
+            self.instructions.push(Instruction::Match(MatchIR {
+                label: effects_label,
+                nav: Nav::Stay,
+                node_type: None,
+                node_field: None,
+                pre_effects: vec![],
+                neg_fields: vec![],
+                post_effects: capture.post,
+                successors: vec![exit],
+            }));
+            effects_label
+        };
+
+        // Emit Call instruction with caller-provided navigation and field constraint.
+        // Return is emitted at definition exit, not here.
+        let call_label = self.fresh_label();
+        self.instructions.push(Instruction::Call(CallIR {
+            label: call_label,
+            nav: nav_override.unwrap_or(Nav::Stay),
+            node_field: field_override,
+            next: return_addr,
+            target,
+        }));
+
+        call_label
+    }
+
+    /// Compile a field constraint: `name: pattern`.
+    pub(super) fn compile_field(&mut self, field: &ast::FieldExpr, exit: Label) -> Label {
+        self.compile_field_inner(field, exit, None, CaptureEffects::default())
+    }
+
+    /// Compile a field constraint with capture effects (passed to inner pattern).
+    pub(super) fn compile_field_inner(
+        &mut self,
+        field: &ast::FieldExpr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        let Some(value) = field.value() else {
+            return exit;
+        };
+
+        let node_field = self.resolve_field(field);
+
+        // Special case: if value is a reference, pass field and capture to Call instruction
+        if let Expr::Ref(r) = &value {
+            return self.compile_ref_inner(r, exit, nav_override, node_field, capture);
+        }
+
+        // Compile the value pattern with nav override and capture effects
+        let value_entry = self.compile_expr_inner(&value, exit, nav_override, capture);
+
+        // If we have a field constraint, try to merge it into the value's instruction
+        if let Some(field_id) = node_field {
+            // Try to find and merge with the instruction we just created
+            if let Some(instr) = self.instructions.iter_mut().find(|i| i.label() == value_entry)
+                && let Instruction::Match(m) = instr
+                && m.node_field.is_none()
+            {
+                m.node_field = Some(field_id);
+                return value_entry;
+            }
+
+            // Fallback: wrap with a field-checking Match for complex patterns
+            let entry = self.fresh_label();
+            self.instructions.push(Instruction::Match(MatchIR {
+                label: entry,
+                nav: Nav::Stay, // Check field without moving
+                node_type: None,
+                node_field: Some(field_id),
+                pre_effects: vec![],
+                neg_fields: vec![],
+                post_effects: vec![],
+                successors: vec![value_entry],
+            }));
+            return entry;
+        }
+
+        value_entry
+    }
+
+    /// Compile a captured expression: `@name` or `pattern @name`.
+    pub(super) fn compile_captured(&mut self, cap: &ast::CapturedExpr, exit: Label) -> Label {
+        self.compile_captured_inner(cap, exit, None, CaptureEffects::default())
+    }
+
+    /// Compile a captured expression with capture effects from outer layers.
+    ///
+    /// Capture effects are placed on the innermost match instruction:
+    /// - Scalar: inner_pattern[Node/Text, Set] → exit
+    /// - Struct: Obj epsilon → inner_pattern[Node/Text, Set] → EndObj epsilon → exit
+    /// - Array:  Arr epsilon → quantifier (with Push on body) → EndArr+Set epsilon → exit
+    /// - Ref:    Call → Set epsilon → exit (structured result needs epsilon)
+    pub(super) fn compile_captured_inner(
+        &mut self,
+        cap: &ast::CapturedExpr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        outer_capture: CaptureEffects,
+    ) -> Label {
+        let inner = cap.inner();
+        let inner_info = inner.as_ref().and_then(|i| self.type_ctx.get_term_info(i));
+        let inner_is_bubble = inner_info.as_ref().is_some_and(|info| info.flow.is_bubble());
+        let inner_creates_scope = inner.as_ref().is_some_and(inner_creates_scope);
+
+        // Scope type for inner compilation:
+        // - Scope-creating expressions (sequences, alternations) push their own scope
+        //   so inner captures reference the sequence's struct type.
+        // - Non-scope-creating bubbles (named nodes) don't push a scope - their fields
+        //   bubble up to the parent scope, so inner captures should reference that.
+        let scope_type_id = if inner_creates_scope {
+            inner_info.as_ref().and_then(|info| info.flow.type_id())
+        } else {
+            None // Bubbles don't create new scopes
+        };
+
+        // Build capture effects: [Node/Text] followed by Set(member_ref)
+        let capture_effects = self.build_capture_effects(cap, inner.as_ref());
+
+        // Bare capture: just emit effects at current position
+        let Some(inner) = inner else {
+            return self.emit_effects_epsilon(exit, capture_effects, outer_capture);
+        };
+
+        // Struct scope: Obj → inner → EndObj+capture → exit
+        if inner_is_bubble {
+            return if inner_creates_scope {
+                // Sequence/alternation: capture effects after EndObj (value is the struct)
+                self.compile_struct_scope(&inner, exit, nav_override, scope_type_id, capture_effects, outer_capture)
+            } else {
+                // Node with bubbles: scope wrapper for inner captures, but capture on inner match
+                self.compile_bubble_with_node_capture(&inner, exit, nav_override, scope_type_id, capture_effects, outer_capture)
+            };
+        }
+
+        // Array: Arr → quantifier (with Push) → EndArr+capture → exit
+        let inner_is_many = inner_info
+            .map(|info| matches!(info.arity, Arity::Many))
+            .unwrap_or_else(|| is_star_or_plus_quantifier(Some(&inner)));
+
+        if inner_is_many {
+            return self.compile_array_scope(&inner, exit, nav_override, capture_effects, outer_capture);
+        }
+
+        // Scalar: capture effects go directly on the match instruction
+        let mut combined = capture_effects;
+        combined.extend(outer_capture.post);
+        self.compile_expr_inner(&inner, exit, nav_override, CaptureEffects { post: combined })
+    }
+
+    /// Resolve an anonymous node's literal text to its node type ID.
+    ///
+    /// In linked mode, returns the grammar NodeTypeId for the literal.
+    /// In unlinked mode, returns the StringId of the literal text.
+    pub(super) fn resolve_anonymous_node_type(&mut self, text: &str) -> Option<NonZeroU16> {
+        if let Some(ids) = self.node_type_ids {
+            // Linked mode: resolve to NodeTypeId from grammar
+            for (&sym, &id) in ids {
+                if self.interner.resolve(sym) == text {
+                    return NonZeroU16::new(id.get());
+                }
+            }
+            // If not found in grammar, treat as no constraint
+            None
+        } else {
+            // Unlinked mode: store StringId referencing the literal text
+            let string_id = self.strings.intern_str(text);
+            NonZeroU16::new(string_id.0)
+        }
+    }
+
+    /// Resolve a NamedNode to its node type ID.
+    ///
+    /// In linked mode, returns the grammar NodeTypeId.
+    /// In unlinked mode, returns the StringId of the type name.
+    pub(super) fn resolve_node_type(&mut self, node: &ast::NamedNode) -> Option<NonZeroU16> {
+        // For wildcard (_), no constraint
+        if node.is_any() {
+            return None;
+        }
+
+        let type_token = node.node_type()?;
+        let type_name = type_token.text();
+
+        if let Some(ids) = self.node_type_ids {
+            // Linked mode: resolve to NodeTypeId from grammar
+            for (&sym, &id) in ids {
+                if self.interner.resolve(sym) == type_name {
+                    return NonZeroU16::new(id.get());
+                }
+            }
+            // If not found in grammar, treat as no constraint (linked mode)
+            None
+        } else {
+            // Unlinked mode: store StringId referencing the type name
+            let string_id = self.strings.intern_str(type_name);
+            NonZeroU16::new(string_id.0)
+        }
+    }
+
+    /// Resolve a field expression to its field ID.
+    ///
+    /// In linked mode, returns the grammar NodeFieldId.
+    /// In unlinked mode, returns the StringId of the field name.
+    pub(super) fn resolve_field(&mut self, field: &ast::FieldExpr) -> Option<NonZeroU16> {
+        let name_token = field.name()?;
+        let field_name = name_token.text();
+        self.resolve_field_by_name(field_name)
+    }
+
+    /// Resolve a field name to its field ID.
+    ///
+    /// In linked mode, returns the grammar NodeFieldId.
+    /// In unlinked mode, returns the StringId of the field name.
+    pub(super) fn resolve_field_by_name(&mut self, field_name: &str) -> Option<NonZeroU16> {
+        if let Some(ids) = self.node_field_ids {
+            // Linked mode: resolve to NodeFieldId from grammar
+            for (&sym, &id) in ids {
+                if self.interner.resolve(sym) == field_name {
+                    return NonZeroU16::new(id.get());
+                }
+            }
+            // If not found in grammar, treat as no constraint (linked mode)
+            None
+        } else {
+            // Unlinked mode: store StringId referencing the field name
+            let string_id = self.strings.intern_str(field_name);
+            NonZeroU16::new(string_id.0)
+        }
+    }
+
+    /// Collect negated fields from a NamedNode.
+    pub(super) fn collect_neg_fields(&mut self, node: &ast::NamedNode) -> Vec<u16> {
+        node.as_cst()
+            .children()
+            .filter_map(ast::NegatedField::cast)
+            .filter_map(|nf| {
+                let name = nf.name()?;
+                self.resolve_field_by_name(name.text())
+            })
+            .map(|id| id.get())
+            .collect()
+    }
+}
diff --git a/crates/plotnik-lib/src/query/compile/mod.rs b/crates/plotnik-lib/src/query/compile/mod.rs
new file mode 100644
index 00000000..86037865
--- /dev/null
+++ b/crates/plotnik-lib/src/query/compile/mod.rs
@@ -0,0 +1,359 @@
+//! Thompson-like NFA construction for query compilation.
+//!
+//! Compiles query AST expressions into bytecode IR with symbolic labels.
+//! Labels are resolved to concrete StepIds during the layout phase.
+//! Member indices use deferred resolution via MemberRef for correct absolute indices.
+//!
+//! # Module Organization
+//!
+//! The compiler is split into focused modules:
+//! - `capture`: Capture effects handling (Node/Text + Set)
+//! - `expressions`: Leaf expression compilation (named/anon nodes, refs, fields, captures)
+//! - `navigation`: Navigation mode computation for anchors and quantifiers
+//! - `quantifier`: Unified quantifier compilation (*, +, ?)
+//! - `scope`: Scope management for struct/array wrappers
+//! - `sequences`: Sequence and alternation compilation
+
+mod capture;
+mod expressions;
+mod navigation;
+mod quantifier;
+mod scope;
+mod sequences;
+
+use indexmap::IndexMap;
+use plotnik_core::{Interner, NodeFieldId, NodeTypeId, Symbol};
+
+use crate::bytecode::ir::{Instruction, Label, ReturnIR};
+use crate::bytecode::Nav;
+use crate::parser::ast::Expr;
+
+use super::codegen::StringTableBuilder;
+use super::symbol_table::SymbolTable;
+use super::type_check::{DefId, TypeContext};
+
+pub use capture::CaptureEffects;
+use scope::StructScope;
+
+/// Error during compilation.
+#[derive(Clone, Debug)]
+pub enum CompileError {
+    /// Definition not found in symbol table.
+    DefinitionNotFound(String),
+    /// Expression body missing.
+    MissingBody(String),
+}
+
+impl std::fmt::Display for CompileError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::DefinitionNotFound(name) => write!(f, "definition not found: {name}"),
+            Self::MissingBody(name) => write!(f, "missing body for definition: {name}"),
+        }
+    }
+}
+
+impl std::error::Error for CompileError {}
+
+/// Result of compilation.
+#[derive(Clone, Debug)]
+pub struct CompileResult {
+    /// All generated instructions.
+    pub instructions: Vec<Instruction>,
+    /// Entry labels for each definition (in definition order).
+    pub def_entries: IndexMap<DefId, Label>,
+}
+
+/// Compiler state for Thompson construction.
+pub struct Compiler<'a> {
+    pub(super) interner: &'a Interner,
+    pub(super) type_ctx: &'a TypeContext,
+    symbol_table: &'a SymbolTable,
+    pub(super) strings: &'a mut StringTableBuilder,
+    pub(super) node_type_ids: Option<&'a IndexMap<Symbol, NodeTypeId>>,
+    pub(super) node_field_ids: Option<&'a IndexMap<Symbol, NodeFieldId>>,
+    pub(super) instructions: Vec<Instruction>,
+    next_label_id: u32,
+    pub(super) def_entries: IndexMap<DefId, Label>,
+    /// Stack of active struct scopes for capture lookup.
+    /// Innermost scope is at the end.
+    pub(super) scope_stack: Vec<StructScope>,
+}
+
+impl<'a> Compiler<'a> {
+    /// Create a new compiler.
+    pub fn new(
+        interner: &'a Interner,
+        type_ctx: &'a TypeContext,
+        symbol_table: &'a SymbolTable,
+        strings: &'a mut StringTableBuilder,
+        node_type_ids: Option<&'a IndexMap<Symbol, NodeTypeId>>,
+        node_field_ids: Option<&'a IndexMap<Symbol, NodeFieldId>>,
+    ) -> Self {
+        Self {
+            interner,
+            type_ctx,
+            symbol_table,
+            strings,
+            node_type_ids,
+            node_field_ids,
+            instructions: Vec::new(),
+            next_label_id: 0,
+            def_entries: IndexMap::new(),
+            scope_stack: Vec::new(),
+        }
+    }
+
+    /// Compile all definitions in the query.
+    pub fn compile(
+        interner: &'a Interner,
+        type_ctx: &'a TypeContext,
+        symbol_table: &'a SymbolTable,
+        strings: &'a mut StringTableBuilder,
+        node_type_ids: Option<&'a IndexMap<Symbol, NodeTypeId>>,
+        node_field_ids: Option<&'a IndexMap<Symbol, NodeFieldId>>,
+    ) -> Result<CompileResult, CompileError> {
+        let mut compiler = Self::new(interner, type_ctx, symbol_table, strings, node_type_ids, node_field_ids);
+
+        // Pre-allocate entry labels for all definitions
+        for (def_id, _) in type_ctx.iter_def_types() {
+            let label = compiler.fresh_label();
+            compiler.def_entries.insert(def_id, label);
+        }
+
+        // Compile each definition
+        for (def_id, _) in type_ctx.iter_def_types() {
+            compiler.compile_def(def_id)?;
+        }
+
+        Ok(CompileResult {
+            instructions: compiler.instructions,
+            def_entries: compiler.def_entries,
+        })
+    }
+
+    /// Generate a fresh label.
+    pub(super) fn fresh_label(&mut self) -> Label {
+        let l = Label(self.next_label_id);
+        self.next_label_id += 1;
+        l
+    }
+
+    /// Compile a single definition.
+    fn compile_def(&mut self, def_id: DefId) -> Result<(), CompileError> {
+        let name_sym = self.type_ctx.def_name_sym(def_id);
+        let name = self.interner.resolve(name_sym);
+
+        let Some(body) = self.symbol_table.get(name) else {
+            return Err(CompileError::DefinitionNotFound(name.to_string()));
+        };
+
+        let entry_label = self.def_entries[&def_id];
+
+        // Create Return instruction at definition exit.
+        // When stack is empty, Return means Accept (top-level match completed).
+        // When stack is non-empty, Return pops frame and jumps to return address.
+        let return_label = self.fresh_label();
+        self.instructions
+            .push(Instruction::Return(ReturnIR { label: return_label }));
+
+        // Compile body with root scope, targeting return instruction
+        let body_entry = if let Some(type_id) = self.type_ctx.get_def_type(def_id) {
+            self.with_scope(type_id, |this| this.compile_expr(body, return_label))
+        } else {
+            self.compile_expr(body, return_label)
+        };
+
+        // If body_entry differs from our pre-allocated entry, emit an epsilon jump
+        if body_entry != entry_label {
+            self.emit_epsilon(entry_label, vec![body_entry]);
+        }
+
+        Ok(())
+    }
+
+    /// Compile an expression, returning its entry label.
+    pub(super) fn compile_expr(&mut self, expr: &Expr, exit: Label) -> Label {
+        match expr {
+            Expr::NamedNode(n) => self.compile_named_node(n, exit),
+            Expr::AnonymousNode(n) => self.compile_anonymous_node(n, exit),
+            Expr::Ref(r) => self.compile_ref(r, exit),
+            Expr::SeqExpr(s) => self.compile_seq(s, exit),
+            Expr::AltExpr(a) => self.compile_alt(a, exit),
+            Expr::QuantifiedExpr(q) => self.compile_quantified(q, exit),
+            Expr::FieldExpr(f) => self.compile_field(f, exit),
+            Expr::CapturedExpr(c) => self.compile_captured(c, exit),
+        }
+    }
+
+    /// Compile an expression with an optional navigation override.
+    pub(super) fn compile_expr_with_nav(&mut self, expr: &Expr, exit: Label, nav_override: Option<Nav>) -> Label {
+        self.compile_expr_inner(expr, exit, nav_override, CaptureEffects::default())
+    }
+
+    /// Compile an expression with navigation override and capture effects.
+    ///
+    /// Capture effects are propagated to the innermost match instruction:
+    /// - Named/Anonymous nodes: effects go on the match
+    /// - Sequences: effects go on last item
+    /// - Alternations: effects go on each branch
+    /// - Other wrappers: effects propagate through
+    pub(super) fn compile_expr_inner(
+        &mut self,
+        expr: &Expr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        match expr {
+            // Leaf nodes: attach capture effects directly
+            Expr::NamedNode(n) => self.compile_named_node_inner(n, exit, nav_override, capture),
+            Expr::AnonymousNode(n) => self.compile_anonymous_node_inner(n, exit, nav_override, capture),
+            // Sequences: pass capture to last item
+            Expr::SeqExpr(s) => self.compile_seq_inner(s, exit, nav_override, capture),
+            // Alternations: pass capture to each branch
+            Expr::AltExpr(a) => self.compile_alt_inner(a, exit, nav_override, capture),
+            // Wrappers: propagate capture through
+            Expr::CapturedExpr(c) => self.compile_captured_inner(c, exit, nav_override, capture),
+            Expr::QuantifiedExpr(q) => self.compile_quantified_inner(q, exit, nav_override, capture),
+            Expr::FieldExpr(f) => self.compile_field_inner(f, exit, nav_override, capture),
+            // Refs: special handling for Call
+            Expr::Ref(r) => self.compile_ref_inner(r, exit, nav_override, None, capture),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::query::QueryBuilder;
+
+    #[test]
+    fn compile_simple_named_node() {
+        let query = QueryBuilder::one_liner("Test = (identifier)")
+            .parse()
+            .unwrap()
+            .analyze();
+
+        let mut strings = StringTableBuilder::new();
+        let result = Compiler::compile(
+            query.interner(),
+            query.type_context(),
+            &query.symbol_table,
+            &mut strings,
+            None,
+            None,
+        )
+        .unwrap();
+
+        // Should have at least one instruction
+        assert!(!result.instructions.is_empty());
+        // Should have one entrypoint
+        assert_eq!(result.def_entries.len(), 1);
+    }
+
+    #[test]
+    fn compile_alternation() {
+        let query = QueryBuilder::one_liner("Test = [(identifier) (number)]")
+            .parse()
+            .unwrap()
+            .analyze();
+
+        let mut strings = StringTableBuilder::new();
+        let result = Compiler::compile(
+            query.interner(),
+            query.type_context(),
+            &query.symbol_table,
+            &mut strings,
+            None,
+            None,
+        )
+        .unwrap();
+
+        assert!(!result.instructions.is_empty());
+    }
+
+    #[test]
+    fn compile_sequence() {
+        let query = QueryBuilder::one_liner("Test = {(comment) (function)}")
+            .parse()
+            .unwrap()
+            .analyze();
+
+        let mut strings = StringTableBuilder::new();
+        let result = Compiler::compile(
+            query.interner(),
+            query.type_context(),
+            &query.symbol_table,
+            &mut strings,
+            None,
+            None,
+        )
+        .unwrap();
+
+        assert!(!result.instructions.is_empty());
+    }
+
+    #[test]
+    fn compile_quantified() {
+        let query = QueryBuilder::one_liner("Test = (identifier)*")
+            .parse()
+            .unwrap()
+            .analyze();
+
+        let mut strings = StringTableBuilder::new();
+        let result = Compiler::compile(
+            query.interner(),
+            query.type_context(),
+            &query.symbol_table,
+            &mut strings,
+            None,
+            None,
+        )
+        .unwrap();
+
+        assert!(!result.instructions.is_empty());
+    }
+
+    #[test]
+    fn compile_capture() {
+        let query = QueryBuilder::one_liner("Test = (identifier) @id")
+            .parse()
+            .unwrap()
+            .analyze();
+
+        let mut strings = StringTableBuilder::new();
+        let result = Compiler::compile(
+            query.interner(),
+            query.type_context(),
+            &query.symbol_table,
+            &mut strings,
+            None,
+            None,
+        )
+        .unwrap();
+
+        assert!(!result.instructions.is_empty());
+    }
+
+    #[test]
+    fn compile_nested() {
+        let query = QueryBuilder::one_liner("Test = (call_expression function: (identifier) @fn)")
+            .parse()
+            .unwrap()
+            .analyze();
+
+        let mut strings = StringTableBuilder::new();
+        let result = Compiler::compile(
+            query.interner(),
+            query.type_context(),
+            &query.symbol_table,
+            &mut strings,
+            None,
+            None,
+        )
+        .unwrap();
+
+        assert!(!result.instructions.is_empty());
+    }
+}
diff --git a/crates/plotnik-lib/src/query/compile/navigation.rs b/crates/plotnik-lib/src/query/compile/navigation.rs
new file mode 100644
index 00000000..eb29f387
--- /dev/null
+++ b/crates/plotnik-lib/src/query/compile/navigation.rs
@@ -0,0 +1,158 @@
+//! Navigation computation for sequence and node compilation.
+//!
+//! Handles anchor-based navigation modes and navigation transformations
+//! for quantifier repeat iterations.
+
+use crate::bytecode::Nav;
+use crate::parser::ast::{Expr, SeqItem};
+
+/// Check if an expression is anonymous (string literal or wildcard).
+pub fn expr_is_anonymous(expr: Option<&Expr>) -> bool {
+    matches!(expr, Some(Expr::AnonymousNode(_)))
+}
+
+/// Check for trailing anchor in items, looking inside sequences if needed.
+/// Returns (has_trailing_anchor, is_strict).
+pub fn check_trailing_anchor(items: &[SeqItem]) -> (bool, bool) {
+    // Direct trailing anchor
+    if matches!(items.last(), Some(SeqItem::Anchor(_))) {
+        let prev_expr = items.iter().rev().skip(1).find_map(|item| {
+            if let SeqItem::Expr(e) = item { Some(e) } else { None }
+        });
+        return (true, expr_is_anonymous(prev_expr));
+    }
+
+    // Check if only child is a sequence with trailing anchor
+    if items.len() == 1
+        && let Some(SeqItem::Expr(Expr::SeqExpr(seq))) = items.first()
+    {
+        let seq_items: Vec<_> = seq.items().collect();
+        return check_trailing_anchor(&seq_items);
+    }
+
+    (false, false)
+}
+
+/// Compute navigation modes for each expression based on anchor context.
+/// Returns a vector of (expression index, nav mode) pairs.
+pub fn compute_nav_modes(items: &[SeqItem], is_inside_node: bool) -> Vec<(usize, Option<Nav>)> {
+    let mut result = Vec::new();
+    let mut pending_anchor = false;
+    let mut prev_is_anonymous = false;
+    let mut is_first_expr = true;
+
+    for (idx, item) in items.iter().enumerate() {
+        match item {
+            SeqItem::Anchor(_) => {
+                pending_anchor = true;
+            }
+            SeqItem::Expr(expr) => {
+                let current_is_anonymous = matches!(expr, Expr::AnonymousNode(_));
+                let nav = if pending_anchor {
+                    // Anchor between previous item and this one
+                    let is_exact = prev_is_anonymous || current_is_anonymous;
+                    if is_first_expr && is_inside_node {
+                        // First child with leading anchor
+                        Some(if is_exact { Nav::DownExact } else { Nav::DownSkip })
+                    } else if !is_first_expr {
+                        // Sibling with anchor
+                        Some(if is_exact { Nav::NextExact } else { Nav::NextSkip })
+                    } else {
+                        // First in sequence (not inside node)
+                        None
+                    }
+                } else if !is_first_expr {
+                    // Normal sibling navigation (no anchor)
+                    Some(Nav::Next)
+                } else {
+                    // First expression - use default (None for sequences, Down for nodes)
+                    None
+                };
+
+                result.push((idx, nav));
+                pending_anchor = false;
+                prev_is_anonymous = current_is_anonymous;
+                is_first_expr = false;
+            }
+        }
+    }
+
+    result
+}
+
+/// Compute navigation for repeat iterations in quantifiers.
+///
+/// When a quantifier repeats, it needs to advance to the next sibling:
+/// - First iteration uses `nav_override` (e.g., Down into parent's children)
+/// - Repeat iterations must use Next to advance to subsequent siblings
+pub fn repeat_nav_for(first_nav: Option<Nav>) -> Option<Nav> {
+    match first_nav {
+        Some(Nav::Down) => Some(Nav::Next),
+        Some(Nav::DownSkip) => Some(Nav::NextSkip),
+        Some(Nav::DownExact) => Some(Nav::NextExact),
+        Some(nav @ (Nav::Next | Nav::NextSkip | Nav::NextExact)) => Some(nav),
+        _ => None,
+    }
+}
+
+/// Check if navigation is a Down variant (descends into children).
+pub fn is_down_nav(nav: Option<Nav>) -> bool {
+    matches!(nav, Some(Nav::Down | Nav::DownSkip | Nav::DownExact))
+}
+
+/// Check if expression is optional (?) or star (*) - patterns that can match zero times.
+/// Unwraps CapturedExpr if present.
+pub fn is_skippable_quantifier(expr: &Expr) -> bool {
+    use crate::parser::cst::SyntaxKind;
+
+    // Unwrap CapturedExpr to check the inner quantifier
+    let expr = match expr {
+        Expr::CapturedExpr(cap) => match cap.inner() {
+            Some(inner) => inner,
+            None => return false,
+        },
+        e => e.clone(),
+    };
+
+    let Expr::QuantifiedExpr(q) = &expr else {
+        return false;
+    };
+    let Some(op) = q.operator() else {
+        return false;
+    };
+    matches!(
+        op.kind(),
+        SyntaxKind::Question
+            | SyntaxKind::QuestionQuestion
+            | SyntaxKind::Star
+            | SyntaxKind::StarQuestion
+    )
+}
+
+/// Syntactic check for star/plus quantifier (fallback when type info unavailable).
+pub fn is_star_or_plus_quantifier(expr: Option<&Expr>) -> bool {
+    use crate::parser::cst::SyntaxKind;
+
+    let Some(Expr::QuantifiedExpr(q)) = expr else {
+        return false;
+    };
+    let Some(op) = q.operator() else {
+        return false;
+    };
+    matches!(
+        op.kind(),
+        SyntaxKind::Star | SyntaxKind::StarQuestion | SyntaxKind::Plus | SyntaxKind::PlusQuestion
+    )
+}
+
+/// Determines if an expression creates a scope boundary when captured.
+/// Sequences and alternations create scopes; named nodes/refs don't.
+pub fn inner_creates_scope(inner: &Expr) -> bool {
+    match inner {
+        Expr::SeqExpr(_) | Expr::AltExpr(_) => true,
+        Expr::QuantifiedExpr(q) => {
+            q.inner().is_some_and(|i| inner_creates_scope(&i))
+        }
+        _ => false,
+    }
+}
diff --git a/crates/plotnik-lib/src/query/compile/quantifier.rs b/crates/plotnik-lib/src/query/compile/quantifier.rs
new file mode 100644
index 00000000..4909faa5
--- /dev/null
+++ b/crates/plotnik-lib/src/query/compile/quantifier.rs
@@ -0,0 +1,439 @@
+//! Unified quantifier compilation.
+//!
+//! Consolidates the 6+ code paths for quantified expression compilation into
+//! a single unified approach with configuration for:
+//! - Whether it's inside an array scope
+//! - Whether it's skippable (first-child with Down navigation)
+//! - Whether skip/match need separate exits
+
+use crate::bytecode::ir::{EffectIR, Label};
+use crate::bytecode::{EffectOpcode, Nav};
+use crate::parser::ast::{self, Expr};
+use crate::parser::cst::SyntaxKind;
+use crate::query::type_check::TypeId;
+
+use super::capture::{check_needs_struct_wrapper, get_row_type_id, CaptureEffects};
+use super::navigation::{is_star_or_plus_quantifier, repeat_nav_for};
+use super::Compiler;
+
+/// Quantifier operator classification.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum QuantifierKind {
+    /// `?` - matches 0 or 1 time
+    Optional,
+    /// `??` - non-greedy optional
+    OptionalNonGreedy,
+    /// `*` - matches 0 or more times
+    Star,
+    /// `*?` - non-greedy star
+    StarNonGreedy,
+    /// `+` - matches 1 or more times
+    Plus,
+    /// `+?` - non-greedy plus
+    PlusNonGreedy,
+}
+
+impl QuantifierKind {
+    /// Parse from a SyntaxKind.
+    pub fn from_syntax(kind: SyntaxKind) -> Option<Self> {
+        match kind {
+            SyntaxKind::Question => Some(Self::Optional),
+            SyntaxKind::QuestionQuestion => Some(Self::OptionalNonGreedy),
+            SyntaxKind::Star => Some(Self::Star),
+            SyntaxKind::StarQuestion => Some(Self::StarNonGreedy),
+            SyntaxKind::Plus => Some(Self::Plus),
+            SyntaxKind::PlusQuestion => Some(Self::PlusNonGreedy),
+            _ => None,
+        }
+    }
+
+    /// Returns true if this is a greedy quantifier.
+    pub fn is_greedy(self) -> bool {
+        matches!(self, Self::Optional | Self::Star | Self::Plus)
+    }
+
+}
+
+/// Configuration for unified quantifier compilation.
+pub struct QuantifierConfig<'a> {
+    /// The inner expression to match.
+    pub inner: &'a Expr,
+    /// The quantifier kind.
+    pub kind: QuantifierKind,
+    /// Navigation for first iteration.
+    pub first_nav: Option<Nav>,
+    /// Whether this is inside an array capture context (needs Push on each iteration).
+    pub in_array_context: bool,
+    /// Capture effects for each iteration (e.g., Push for arrays).
+    pub element_capture: CaptureEffects,
+    /// When true, skip and match paths need separate exit labels.
+    pub needs_split_exits: bool,
+    /// Exit for match path (when needs_split_exits is true).
+    pub match_exit: Label,
+    /// Exit for skip path (when needs_split_exits is true). Only used for skippable quantifiers.
+    pub skip_exit: Option<Label>,
+}
+
+impl Compiler<'_> {
+    /// Compile a quantified expression: `a?`, `a*`, `a+`.
+    pub(super) fn compile_quantified(&mut self, quant: &ast::QuantifiedExpr, exit: Label) -> Label {
+        self.compile_quantified_inner(quant, exit, None, CaptureEffects::default())
+    }
+
+    /// Compile a quantified expression with capture effects (passed to body).
+    pub(super) fn compile_quantified_inner(
+        &mut self,
+        quant: &ast::QuantifiedExpr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        let Some(inner) = quant.inner() else {
+            return exit;
+        };
+
+        let Some(op) = quant.operator() else {
+            return self.compile_expr_inner(&inner, exit, nav_override, capture);
+        };
+
+        let Some(kind) = QuantifierKind::from_syntax(op.kind()) else {
+            return self.compile_expr_inner(&inner, exit, nav_override, capture);
+        };
+
+        let config = QuantifierConfig {
+            inner: &inner,
+            kind,
+            first_nav: nav_override,
+            in_array_context: false,
+            element_capture: capture,
+            needs_split_exits: false,
+            match_exit: exit,
+            skip_exit: None,
+        };
+
+        self.compile_quantified_unified(config)
+    }
+
+    /// Compile a quantified expression for array capture with element-level effects.
+    ///
+    /// The element_capture effects (typically [Push]) are placed on each iteration.
+    pub(super) fn compile_quantified_for_array(
+        &mut self,
+        quant: &ast::QuantifiedExpr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        element_capture: CaptureEffects,
+    ) -> Label {
+        let Some(inner) = quant.inner() else {
+            return exit;
+        };
+
+        let Some(op) = quant.operator() else {
+            return self.compile_expr_inner(&inner, exit, nav_override, element_capture);
+        };
+
+        let Some(kind) = QuantifierKind::from_syntax(op.kind()) else {
+            return self.compile_expr_inner(&inner, exit, nav_override, element_capture);
+        };
+
+        let config = QuantifierConfig {
+            inner: &inner,
+            kind,
+            first_nav: nav_override,
+            in_array_context: true,
+            element_capture,
+            needs_split_exits: false,
+            match_exit: exit,
+            skip_exit: None,
+        };
+
+        self.compile_quantified_unified(config)
+    }
+
+    /// Compile a skippable expression (optional/star) with separate exits for skip/match paths.
+    pub(super) fn compile_skippable_with_exits(
+        &mut self,
+        expr: &Expr,
+        match_exit: Label,
+        skip_exit: Label,
+        nav_override: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        // Handle CapturedExpr wrapping
+        if let Expr::CapturedExpr(cap) = expr
+            && let Some(inner) = cap.inner()
+        {
+            // Array capture: need special handling with Arr/EndArr
+            if is_star_or_plus_quantifier(Some(&inner)) {
+                return self.compile_array_capture_with_exits(
+                    cap, &inner, match_exit, skip_exit, nav_override, capture,
+                );
+            }
+
+            // Non-array capture: build capture effects and recurse
+            let capture_effects = self.build_capture_effects(cap, Some(&inner));
+            let mut combined = CaptureEffects { post: capture_effects };
+            combined.post.extend(capture.post);
+
+            return self.compile_skippable_with_exits(
+                &inner, match_exit, skip_exit, nav_override, combined,
+            );
+        }
+
+        // Must be a QuantifiedExpr at this point
+        let Expr::QuantifiedExpr(quant) = expr else {
+            return self.compile_expr_inner(expr, match_exit, nav_override, capture);
+        };
+
+        let Some(inner) = quant.inner() else {
+            return match_exit;
+        };
+
+        let Some(op) = quant.operator() else {
+            return self.compile_expr_inner(&inner, match_exit, nav_override, capture);
+        };
+
+        let Some(kind) = QuantifierKind::from_syntax(op.kind()) else {
+            return self.compile_expr_inner(&inner, match_exit, nav_override, capture);
+        };
+
+        // Handle null injection for both passed captures and internal captures
+        let skip_with_null = self.emit_null_for_skip_path(skip_exit, &capture);
+        let skip_with_internal_null = self.emit_null_for_internal_captures(skip_with_null, &inner);
+
+        let config = QuantifierConfig {
+            inner: &inner,
+            kind,
+            first_nav: nav_override,
+            in_array_context: false,
+            element_capture: capture,
+            needs_split_exits: true,
+            match_exit,
+            skip_exit: Some(skip_with_internal_null),
+        };
+
+        self.compile_quantified_unified(config)
+    }
+
+    /// Compile an array capture (star/plus with @capture) as first-child with separate exits.
+    ///
+    /// For array captures, we need:
+    /// - Arr step at entry
+    /// - Two EndArr steps: one for skip (→ skip_exit), one for match (→ match_exit)
+    /// - Star compiled to route skip to skip_EndArr, loop exit to match_EndArr
+    fn compile_array_capture_with_exits(
+        &mut self,
+        cap: &ast::CapturedExpr,
+        inner: &Expr,
+        match_exit: Label,
+        skip_exit: Label,
+        nav_override: Option<Nav>,
+        outer_capture: CaptureEffects,
+    ) -> Label {
+        let capture_effects = self.build_capture_effects(cap, Some(inner));
+
+        // Create two EndArr steps with different continuations
+        let match_endarr = self.emit_endarr_step(&capture_effects, &outer_capture.post, match_exit);
+        let skip_endarr = self.emit_endarr_step(&capture_effects, &outer_capture.post, skip_exit);
+
+        // Compile inner star with Push effects and split exits
+        let push_effects = CaptureEffects {
+            post: vec![EffectIR::simple(EffectOpcode::Push, 0)],
+        };
+        let inner_entry =
+            self.compile_star_for_array_with_exits(inner, match_endarr, skip_endarr, nav_override, push_effects);
+
+        // Emit Arr step at entry
+        self.emit_arr_step(inner_entry)
+    }
+
+    /// Compile a star quantifier for array context with separate exits.
+    fn compile_star_for_array_with_exits(
+        &mut self,
+        expr: &Expr,
+        match_exit: Label,
+        skip_exit: Label,
+        nav_override: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        let Expr::QuantifiedExpr(quant) = expr else {
+            return self.compile_expr_inner(expr, match_exit, nav_override, capture);
+        };
+
+        let Some(inner) = quant.inner() else {
+            return match_exit;
+        };
+
+        let Some(op) = quant.operator() else {
+            return self.compile_expr_inner(&inner, match_exit, nav_override, capture);
+        };
+
+        let Some(kind) = QuantifierKind::from_syntax(op.kind()) else {
+            return self.compile_expr_inner(&inner, match_exit, nav_override, capture);
+        };
+
+        let config = QuantifierConfig {
+            inner: &inner,
+            kind,
+            first_nav: nav_override,
+            in_array_context: true,
+            element_capture: capture,
+            needs_split_exits: true,
+            match_exit,
+            skip_exit: Some(skip_exit),
+        };
+
+        self.compile_quantified_unified(config)
+    }
+
+    /// Unified quantifier compilation.
+    ///
+    /// This is the single entry point for all quantifier compilation, handling:
+    /// - Star (`*`), Plus (`+`), and Optional (`?`) quantifiers
+    /// - Greedy and non-greedy variants
+    /// - Array context (with struct wrappers if needed)
+    /// - Split exits for first-child skippable patterns
+    fn compile_quantified_unified(&mut self, config: QuantifierConfig<'_>) -> Label {
+        let QuantifierConfig {
+            inner,
+            kind,
+            first_nav,
+            in_array_context,
+            element_capture,
+            needs_split_exits,
+            match_exit,
+            skip_exit,
+        } = config;
+
+        // Determine if struct wrapper is needed (once, here)
+        let needs_struct_wrapper = in_array_context && check_needs_struct_wrapper(inner, self.type_ctx);
+        let row_type_id = if in_array_context {
+            get_row_type_id(inner, self.type_ctx)
+        } else {
+            None
+        };
+
+        // Compile body helper - handles struct wrapper logic in one place
+        let compile_body = |this: &mut Self, nav: Option<Nav>, exit: Label| -> Label {
+            if needs_struct_wrapper {
+                this.compile_struct_for_array(inner, exit, nav, row_type_id)
+            } else if in_array_context {
+                this.compile_with_optional_scope(row_type_id, |t| {
+                    t.compile_expr_inner(inner, exit, nav, element_capture.clone())
+                })
+            } else {
+                this.compile_expr_inner(inner, exit, nav, element_capture.clone())
+            }
+        };
+
+        let is_greedy = kind.is_greedy();
+        let repeat_nav = repeat_nav_for(first_nav);
+
+        match kind {
+            QuantifierKind::Plus | QuantifierKind::PlusNonGreedy => {
+                // +: first_body → loop → [repeat_body, exit]
+                let loop_entry = self.fresh_label();
+
+                let first_body_entry = compile_body(self, first_nav, loop_entry);
+                let repeat_body_entry = compile_body(self, repeat_nav, loop_entry);
+
+                let successors = if is_greedy {
+                    vec![repeat_body_entry, match_exit]
+                } else {
+                    vec![match_exit, repeat_body_entry]
+                };
+                self.emit_epsilon(loop_entry, successors);
+
+                first_body_entry
+            }
+
+            QuantifierKind::Star | QuantifierKind::StarNonGreedy => {
+                if needs_split_exits {
+                    // Star with split exits: entry → [first_body → loop → [repeat_body, match_exit], skip_exit]
+                    let skip = skip_exit.expect("split exits requires skip_exit");
+                    self.compile_star_with_split_exits(
+                        inner, match_exit, skip, first_nav, element_capture, is_greedy,
+                        needs_struct_wrapper, row_type_id,
+                    )
+                } else {
+                    // Regular star: entry → [first_body → loop → [repeat_body, exit], exit]
+                    let loop_entry = self.fresh_label();
+
+                    let first_body_entry = compile_body(self, first_nav, loop_entry);
+                    let repeat_body_entry = compile_body(self, repeat_nav, loop_entry);
+
+                    // Entry point branches: first iteration or exit
+                    let entry = self.fresh_label();
+                    let successors = if is_greedy {
+                        vec![first_body_entry, match_exit]
+                    } else {
+                        vec![match_exit, first_body_entry]
+                    };
+                    self.emit_epsilon(entry, successors);
+
+                    // Loop point branches: repeat iteration or exit
+                    let loop_successors = if is_greedy {
+                        vec![repeat_body_entry, match_exit]
+                    } else {
+                        vec![match_exit, repeat_body_entry]
+                    };
+                    self.emit_epsilon(loop_entry, loop_successors);
+
+                    entry
+                }
+            }
+
+            QuantifierKind::Optional | QuantifierKind::OptionalNonGreedy => {
+                // ?: branch to body or exit
+                let body_entry = compile_body(self, first_nav, match_exit);
+
+                if needs_split_exits {
+                    // Split exits for optional
+                    let skip = skip_exit.expect("split exits requires skip_exit");
+                    self.emit_branch_epsilon(body_entry, skip, is_greedy)
+                } else {
+                    // Regular optional with null emission for skipped captures
+                    // First handle captures passed as effects (e.g., `(x)? @cap`)
+                    let skip_with_null = self.emit_null_for_skip_path(match_exit, &element_capture);
+                    // Then handle internal captures (e.g., `{(x) @cap}?`)
+                    let skip_with_internal_null = self.emit_null_for_internal_captures(skip_with_null, inner);
+                    self.emit_branch_epsilon(body_entry, skip_with_internal_null, is_greedy)
+                }
+            }
+        }
+    }
+
+    /// Helper for star with split exits - handles the complex case where skip and match
+    /// paths need different continuations.
+    #[allow(clippy::too_many_arguments)]
+    fn compile_star_with_split_exits(
+        &mut self,
+        inner: &Expr,
+        match_exit: Label,
+        skip_exit: Label,
+        nav_override: Option<Nav>,
+        capture: CaptureEffects,
+        is_greedy: bool,
+        needs_struct_wrapper: bool,
+        row_type_id: Option<TypeId>,
+    ) -> Label {
+        let loop_entry = self.fresh_label();
+        let repeat_nav = repeat_nav_for(nav_override);
+
+        let first_body = if needs_struct_wrapper {
+            self.compile_struct_for_array(inner, loop_entry, nav_override, row_type_id)
+        } else {
+            self.compile_expr_inner(inner, loop_entry, nav_override, capture.clone())
+        };
+
+        let repeat_body = if needs_struct_wrapper {
+            self.compile_struct_for_array(inner, loop_entry, repeat_nav, row_type_id)
+        } else {
+            self.compile_expr_inner(inner, loop_entry, repeat_nav, capture)
+        };
+
+        let entry = self.emit_branch_epsilon(first_body, skip_exit, is_greedy);
+        self.emit_branch_epsilon_at(loop_entry, repeat_body, match_exit, is_greedy);
+        entry
+    }
+}
diff --git a/crates/plotnik-lib/src/query/compile/scope.rs b/crates/plotnik-lib/src/query/compile/scope.rs
new file mode 100644
index 00000000..be5280bd
--- /dev/null
+++ b/crates/plotnik-lib/src/query/compile/scope.rs
@@ -0,0 +1,446 @@
+//! Scope management for structured captures.
+//!
+//! Handles Obj/EndObj and Arr/EndArr wrapper emission for struct and array captures.
+
+use crate::bytecode::ir::{EffectIR, Instruction, Label, MatchIR, MemberRef};
+use crate::bytecode::{EffectOpcode, Nav};
+use crate::parser::ast::Expr;
+use crate::query::type_check::TypeId;
+
+use super::capture::CaptureEffects;
+use super::Compiler;
+
+/// Struct scope for tracking captures in nested contexts.
+/// Each scope represents a struct type whose fields can receive captures.
+#[derive(Clone, Copy, Debug)]
+pub struct StructScope(pub TypeId);
+
+impl Compiler<'_> {
+    /// Execute with optional scope - avoids repeated if-let pattern.
+    pub(super) fn compile_with_optional_scope<T>(
+        &mut self,
+        type_id: Option<TypeId>,
+        f: impl FnOnce(&mut Self) -> T,
+    ) -> T {
+        if let Some(type_id) = type_id {
+            self.with_scope(type_id, f)
+        } else {
+            f(self)
+        }
+    }
+
+    /// Execute a closure with a scope pushed, automatically popping afterward.
+    pub(super) fn with_scope<T>(&mut self, type_id: TypeId, f: impl FnOnce(&mut Self) -> T) -> T {
+        self.scope_stack.push(StructScope(type_id));
+        let result = f(self);
+        self.scope_stack.pop();
+        result
+    }
+
+    /// Look up a capture name in a type, returning a deferred member reference.
+    pub(super) fn lookup_member(&self, capture_name: &str, type_id: TypeId) -> Option<MemberRef> {
+        let fields = self.type_ctx.get_struct_fields(type_id)?;
+        for (relative_index, (&sym, _)) in fields.iter().enumerate() {
+            if self.interner.resolve(sym) == capture_name {
+                return Some(MemberRef::deferred(type_id, relative_index as u16));
+            }
+        }
+        None
+    }
+
+    /// Look up a capture name in the current scope stack.
+    pub(super) fn lookup_member_in_scope(&self, capture_name: &str) -> Option<MemberRef> {
+        let StructScope(type_id) = *self.scope_stack.last()?;
+        self.lookup_member(capture_name, type_id)
+    }
+
+    /// Compile struct scope: Obj → inner → EndObj+capture → exit
+    pub(super) fn compile_struct_scope(
+        &mut self,
+        inner: &Expr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        scope_type_id: Option<TypeId>,
+        capture_effects: Vec<EffectIR>,
+        outer_capture: CaptureEffects,
+    ) -> Label {
+        let mut end_effects = vec![EffectIR::simple(EffectOpcode::EndObj, 0)];
+        end_effects.extend(capture_effects);
+        end_effects.extend(outer_capture.post);
+
+        let endobj_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: endobj_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: end_effects,
+            successors: vec![exit],
+        }));
+
+        let inner_entry = self.compile_with_optional_scope(scope_type_id, |this| {
+            this.compile_expr_with_nav(inner, endobj_step, nav_override)
+        });
+
+        let obj_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: obj_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![EffectIR::simple(EffectOpcode::Obj, 0)],
+            neg_fields: vec![],
+            post_effects: vec![],
+            successors: vec![inner_entry],
+        }));
+
+        obj_step
+    }
+
+    /// Compile bubble with node capture: inner[capture] → exit (with optional outer effects)
+    ///
+    /// Used when a named node contains bubbling captures but the capture itself
+    /// should capture the node value (not a struct). The capture_effects go on
+    /// the inner match instruction, and outer_capture effects are emitted after.
+    ///
+    /// Note: Previously this always wrapped in Obj/EndObj, but that was incorrect
+    /// when scope_type_id is None. The inner captures use the current scope from
+    /// the outer context (e.g., array row struct), so no new scope is needed.
+    pub(super) fn compile_bubble_with_node_capture(
+        &mut self,
+        inner: &Expr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        scope_type_id: Option<TypeId>,
+        capture_effects: Vec<EffectIR>,
+        outer_capture: CaptureEffects,
+    ) -> Label {
+        // When scope_type_id is None, inner captures use the current scope
+        // (no new Obj/EndObj scope needed - just compile with combined effects)
+        if scope_type_id.is_none() {
+            // If we have outer_capture effects (like Push), emit epsilon step for them
+            let actual_exit = if outer_capture.post.is_empty() {
+                exit
+            } else {
+                let outer_step = self.fresh_label();
+                self.instructions.push(Instruction::Match(MatchIR {
+                    label: outer_step,
+                    nav: Nav::Stay,
+                    node_type: None,
+                    node_field: None,
+                    pre_effects: vec![],
+                    neg_fields: vec![],
+                    post_effects: outer_capture.post,
+                    successors: vec![exit],
+                }));
+                outer_step
+            };
+
+            // Compile inner with capture_effects on the match instruction
+            let inner_capture = CaptureEffects { post: capture_effects };
+            return self.compile_expr_inner(inner, actual_exit, nav_override, inner_capture);
+        }
+
+        // When scope_type_id is Some, we need Obj/EndObj to create the scope
+        // EndObj step with ONLY outer_capture effects (like Push), NOT capture_effects
+        let mut end_effects = vec![EffectIR::simple(EffectOpcode::EndObj, 0)];
+        end_effects.extend(outer_capture.post);
+
+        let endobj_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: endobj_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: end_effects,
+            successors: vec![exit],
+        }));
+
+        // Compile inner WITH capture_effects on the match instruction
+        let inner_capture = CaptureEffects { post: capture_effects };
+        let inner_entry = self.with_scope(scope_type_id.unwrap(), |this| {
+            this.compile_expr_inner(inner, endobj_step, nav_override, inner_capture)
+        });
+
+        let obj_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: obj_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![EffectIR::simple(EffectOpcode::Obj, 0)],
+            neg_fields: vec![],
+            post_effects: vec![],
+            successors: vec![inner_entry],
+        }));
+
+        obj_step
+    }
+
+    /// Compile array scope: Arr → quantifier (with Push) → EndArr+capture → exit
+    pub(super) fn compile_array_scope(
+        &mut self,
+        inner: &Expr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        capture_effects: Vec<EffectIR>,
+        outer_capture: CaptureEffects,
+    ) -> Label {
+        let mut end_effects = vec![EffectIR::simple(EffectOpcode::EndArr, 0)];
+        end_effects.extend(capture_effects);
+        end_effects.extend(outer_capture.post);
+
+        let endarr_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: endarr_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: end_effects,
+            successors: vec![exit],
+        }));
+
+        let push_effects = CaptureEffects {
+            post: vec![EffectIR::simple(EffectOpcode::Push, 0)],
+        };
+        let inner_entry = if let Expr::QuantifiedExpr(quant) = inner {
+            self.compile_quantified_for_array(quant, endarr_step, nav_override, push_effects)
+        } else {
+            self.compile_expr_with_nav(inner, endarr_step, nav_override)
+        };
+
+        let arr_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: arr_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![EffectIR::simple(EffectOpcode::Arr, 0)],
+            neg_fields: vec![],
+            post_effects: vec![],
+            successors: vec![inner_entry],
+        }));
+
+        arr_step
+    }
+
+    /// Compile an expression with Obj/EndObj wrapping for array iteration.
+    ///
+    /// Used when inner is a scope-creating expression (sequence/alternation) with
+    /// internal captures. Each iteration produces: Obj → inner → EndObj Push
+    pub(super) fn compile_struct_for_array(
+        &mut self,
+        inner: &Expr,
+        exit: Label,
+        nav_override: Option<Nav>,
+        row_type_id: Option<TypeId>,
+    ) -> Label {
+        // EndObj Push → exit
+        let endobj_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: endobj_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: vec![
+                EffectIR::simple(EffectOpcode::EndObj, 0),
+                EffectIR::simple(EffectOpcode::Push, 0),
+            ],
+            successors: vec![exit],
+        }));
+
+        // Compile inner with row scope (for Set effects to work)
+        let inner_entry = self.compile_with_optional_scope(row_type_id, |this| {
+            this.compile_expr_with_nav(inner, endobj_step, nav_override)
+        });
+
+        // Obj → inner_entry
+        let obj_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: obj_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![EffectIR::simple(EffectOpcode::Obj, 0)],
+            neg_fields: vec![],
+            post_effects: vec![],
+            successors: vec![inner_entry],
+        }));
+
+        obj_step
+    }
+
+    /// Emit an EndArr epsilon step with the given effects.
+    pub(super) fn emit_endarr_step(
+        &mut self,
+        capture_effects: &[EffectIR],
+        outer_effects: &[EffectIR],
+        exit: Label,
+    ) -> Label {
+        let mut effects = vec![EffectIR::simple(EffectOpcode::EndArr, 0)];
+        effects.extend(capture_effects.iter().cloned());
+        effects.extend(outer_effects.iter().cloned());
+
+        let label = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: effects,
+            successors: vec![exit],
+        }));
+        label
+    }
+
+    /// Emit an Arr epsilon step.
+    pub(super) fn emit_arr_step(&mut self, successor: Label) -> Label {
+        let label = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![EffectIR::simple(EffectOpcode::Arr, 0)],
+            neg_fields: vec![],
+            post_effects: vec![],
+            successors: vec![successor],
+        }));
+        label
+    }
+
+    /// Emit an epsilon with combined effects.
+    pub(super) fn emit_effects_epsilon(
+        &mut self,
+        exit: Label,
+        mut effects: Vec<EffectIR>,
+        outer: CaptureEffects,
+    ) -> Label {
+        effects.extend(outer.post);
+        let entry = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: entry,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: effects,
+            successors: vec![exit],
+        }));
+        entry
+    }
+
+    /// Emit null effects for a skip path in optional/star quantifiers.
+    ///
+    /// When an optional/star pattern is skipped, any captures it would have set
+    /// need to be explicitly nulled. This mirrors the null injection that
+    /// alternations do for asymmetric branches.
+    ///
+    /// Returns the new exit label (with null effects) or the original exit if
+    /// no null effects are needed.
+    pub(super) fn emit_null_for_skip_path(&mut self, exit: Label, capture: &CaptureEffects) -> Label {
+        // Collect Set effects - these are the fields that need nulling
+        let null_effects: Vec<_> = capture
+            .post
+            .iter()
+            .filter(|eff| eff.opcode == EffectOpcode::Set)
+            .flat_map(|set_eff| {
+                [
+                    EffectIR::simple(EffectOpcode::Null, 0),
+                    set_eff.clone(),
+                ]
+            })
+            .collect();
+
+        if null_effects.is_empty() {
+            return exit;
+        }
+
+        let null_step = self.fresh_label();
+        self.instructions.push(Instruction::Match(MatchIR {
+            label: null_step,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: null_effects,
+            successors: vec![exit],
+        }));
+        null_step
+    }
+
+    /// Emit null effects for internal captures when skipping an optional/star pattern.
+    ///
+    /// Unlike `emit_null_for_skip_path` which handles captures passed as effects,
+    /// this function handles captures defined INSIDE the expression (e.g., `{(x) @cap}?`).
+    /// It collects all capture names from the expression and emits Null Set for each.
+    pub(super) fn emit_null_for_internal_captures(&mut self, exit: Label, inner: &Expr) -> Label {
+        let captures = Self::collect_captures(inner);
+        if captures.is_empty() {
+            return exit;
+        }
+
+        let mut null_effects = Vec::new();
+        for name in captures {
+            if let Some(member_ref) = self.lookup_member_in_scope(&name) {
+                null_effects.push(EffectIR::simple(EffectOpcode::Null, 0));
+                null_effects.push(EffectIR::with_member(EffectOpcode::Set, member_ref));
+            }
+        }
+
+        if null_effects.is_empty() {
+            return exit;
+        }
+
+        self.emit_effects_epsilon(exit, null_effects, CaptureEffects::default())
+    }
+
+    /// Emit an epsilon transition (no node interaction).
+    pub(super) fn emit_epsilon(&mut self, label: Label, successors: Vec<Label>) {
+        self.instructions.push(Instruction::Match(MatchIR {
+            label,
+            nav: Nav::Stay,
+            node_type: None,
+            node_field: None,
+            pre_effects: vec![],
+            neg_fields: vec![],
+            post_effects: vec![],
+            successors,
+        }));
+    }
+
+    /// Emit an epsilon branch preferring `prefer` when greedy, `other` when non-greedy.
+    pub(super) fn emit_branch_epsilon(&mut self, prefer: Label, other: Label, is_greedy: bool) -> Label {
+        let entry = self.fresh_label();
+        self.emit_branch_epsilon_at(entry, prefer, other, is_greedy);
+        entry
+    }
+
+    /// Emit an epsilon branch at a specific label.
+    pub(super) fn emit_branch_epsilon_at(
+        &mut self,
+        label: Label,
+        prefer: Label,
+        other: Label,
+        is_greedy: bool,
+    ) {
+        let successors = if is_greedy {
+            vec![prefer, other]
+        } else {
+            vec![other, prefer]
+        };
+        self.emit_epsilon(label, successors);
+    }
+}
diff --git a/crates/plotnik-lib/src/query/compile/sequences.rs b/crates/plotnik-lib/src/query/compile/sequences.rs
new file mode 100644
index 00000000..bafbca17
--- /dev/null
+++ b/crates/plotnik-lib/src/query/compile/sequences.rs
@@ -0,0 +1,325 @@
+//! Sequence and alternation compilation.
+//!
+//! Handles compilation of:
+//! - Sequences: `{a b c}` - siblings matched in order
+//! - Alternations: `[a b c]` - first matching branch wins
+
+use crate::bytecode::ir::{EffectIR, Instruction, Label, MatchIR, MemberRef};
+use crate::bytecode::{EffectOpcode, Nav};
+use crate::parser::ast::{self, Expr, SeqItem};
+use crate::query::type_check::TypeShape;
+
+use super::capture::CaptureEffects;
+use super::navigation::{compute_nav_modes, is_down_nav, is_skippable_quantifier, repeat_nav_for};
+use super::Compiler;
+
+impl Compiler<'_> {
+    /// Compile a sequence: `{a b c}`.
+    pub(super) fn compile_seq(&mut self, seq: &ast::SeqExpr, exit: Label) -> Label {
+        self.compile_seq_inner(seq, exit, None, CaptureEffects::default())
+    }
+
+    /// Compile a sequence with capture effects (passed to last item).
+    pub(super) fn compile_seq_inner(
+        &mut self,
+        seq: &ast::SeqExpr,
+        exit: Label,
+        first_nav: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        let items: Vec<_> = seq.items().collect();
+        if items.is_empty() {
+            return exit;
+        }
+
+        // Determine if we're inside a node based on the navigation override
+        // Down variants mean we're descending into a node's children
+        let is_inside_node = matches!(first_nav, Some(Nav::Down | Nav::DownSkip | Nav::DownExact));
+
+        self.compile_seq_items_inner(&items, exit, is_inside_node, first_nav, capture, None)
+    }
+
+    /// Compile sequence items with capture effects (passed to last item).
+    ///
+    /// When `skip_exit` is provided, the skip path of the first skippable item
+    /// will use this exit instead of `exit`. This is used when inside a node
+    /// where skip paths should bypass the Up instruction.
+    pub(super) fn compile_seq_items_inner(
+        &mut self,
+        items: &[SeqItem],
+        exit: Label,
+        is_inside_node: bool,
+        first_nav: Option<Nav>,
+        capture: CaptureEffects,
+        skip_exit: Option<Label>,
+    ) -> Label {
+        // Compute navigation modes first (immutable borrow)
+        let mut nav_modes = compute_nav_modes(items, is_inside_node);
+
+        if nav_modes.is_empty() {
+            return exit;
+        }
+
+        // Apply navigation to first expression
+        let first_expr_nav = if let Some((_, first_mode)) = nav_modes.first_mut()
+            && first_mode.is_none()
+        {
+            let nav = first_nav.or_else(|| is_inside_node.then_some(Nav::Down));
+            *first_mode = nav;
+            nav
+        } else {
+            nav_modes.first().and_then(|(_, n)| *n)
+        };
+
+        // 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
+            .first()
+            .and_then(|item| item.as_expr())
+            .is_some_and(is_skippable_quantifier);
+        let first_uses_down = is_down_nav(first_expr_nav);
+        let needs_skip_exit =
+            first_is_skippable && first_uses_down && (nav_modes.len() > 1 || skip_exit.is_some());
+
+        if needs_skip_exit {
+            // Special handling: first item can skip and uses Down navigation.
+            // The continuation needs two versions:
+            // - skip_exit: uses Down nav (skipping means next item becomes "first")
+            // - match_exit: uses Next nav (after matching, advance to sibling)
+            return self.compile_seq_items_with_skip_exit(
+                items,
+                &nav_modes,
+                exit,
+                is_inside_node,
+                first_expr_nav,
+                capture,
+                skip_exit,
+            );
+        }
+
+        // Build chain in reverse: last expression exits to `exit`, each prior exits to next
+        // Capture effects go to the FIRST iteration (which is the last expression)
+        let mut current_exit = exit;
+        let mut is_last = true;
+        for (expr_idx, nav_override) in nav_modes.into_iter().rev() {
+            let expr = items[expr_idx].as_expr().expect("nav_modes only contains expr indices");
+            if is_last {
+                // Last expression gets capture effects
+                current_exit = self.compile_expr_inner(expr, current_exit, nav_override, capture.clone());
+                is_last = false;
+            } else {
+                current_exit = self.compile_expr_with_nav(expr, current_exit, nav_override);
+            }
+        }
+        current_exit
+    }
+
+    /// Compile sequence items where first item is skippable and uses Down navigation.
+    ///
+    /// When the first item (optional/star) is skipped, the next item becomes the "first"
+    /// and needs to use Down navigation instead of Next. This requires compiling the
+    /// continuation twice with different navigation.
+    ///
+    /// When `caller_skip_exit` is provided and there are no remaining items, the skip
+    /// path uses this exit (to bypass Up in parent node) while match path uses `exit`.
+    #[allow(clippy::too_many_arguments)]
+    fn compile_seq_items_with_skip_exit(
+        &mut self,
+        items: &[SeqItem],
+        nav_modes: &[(usize, Option<Nav>)],
+        exit: Label,
+        is_inside_node: bool,
+        first_nav: Option<Nav>,
+        capture: CaptureEffects,
+        caller_skip_exit: Option<Label>,
+    ) -> Label {
+        let first_expr = items[nav_modes[0].0]
+            .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() {
+            (caller_skip_exit.unwrap_or(exit), exit)
+        } else {
+            let skip = self.compile_seq_items_inner(
+                &rest_items,
+                exit,
+                is_inside_node,
+                first_nav, // Down variant for skip path
+                capture.clone(),
+                caller_skip_exit, // Propagate for nested skippables
+            );
+            let mtch = self.compile_seq_items_inner(
+                &rest_items,
+                exit,
+                is_inside_node,
+                repeat_nav_for(first_nav), // Next variant for match path
+                capture.clone(),
+                None, // Match path doesn't need skip exit
+            );
+            (skip, mtch)
+        };
+
+        self.compile_skippable_with_exits(first_expr, match_exit, skip_exit, first_nav, capture)
+    }
+
+    /// Compile an alternation: `[a b c]`.
+    pub(super) fn compile_alt(&mut self, alt: &ast::AltExpr, exit: Label) -> Label {
+        self.compile_alt_inner(alt, exit, None, CaptureEffects::default())
+    }
+
+    /// Compile an alternation with capture effects (passed to each branch).
+    pub(super) fn compile_alt_inner(
+        &mut self,
+        alt: &ast::AltExpr,
+        exit: Label,
+        first_nav: Option<Nav>,
+        capture: CaptureEffects,
+    ) -> Label {
+        let branches: Vec<_> = alt.branches().collect();
+        if branches.is_empty() {
+            return exit;
+        }
+
+        // Get alternation's type info
+        let alt_expr = Expr::AltExpr(alt.clone());
+        let alt_type_id = self
+            .type_ctx
+            .get_term_info(&alt_expr)
+            .and_then(|info| info.flow.type_id());
+        let alt_type_shape = alt_type_id.and_then(|id| self.type_ctx.get_type(id));
+        let is_enum = alt_type_shape.is_some_and(|shape| matches!(shape, TypeShape::Enum(_)));
+
+        // For tagged alternations: get variant types for scope pushing
+        // For untagged alternations: get merged struct fields for Null injection
+        let variant_types: Vec<_> = match alt_type_shape {
+            Some(TypeShape::Enum(variants)) => variants.values().copied().collect(),
+            _ => vec![],
+        };
+        let merged_fields = alt_type_id.and_then(|id| self.type_ctx.get_struct_fields(id));
+
+        // Compile each branch, collecting entry labels
+        // Each branch gets the same nav override since any branch could match first
+        let mut successors = Vec::new();
+        for (variant_idx, branch) in branches.iter().enumerate() {
+            let Some(body) = branch.body() else {
+                continue;
+            };
+
+            if is_enum {
+                // Tagged branch: E(variant_ref) → body → EndE → exit
+                // Outer capture effects go on EndEnum, not on the branch body
+                let mut end_effects = vec![EffectIR::simple(EffectOpcode::EndEnum, 0)];
+                end_effects.extend(capture.post.iter().cloned());
+
+                let ende_step = self.fresh_label();
+                self.instructions.push(Instruction::Match(MatchIR {
+                    label: ende_step,
+                    nav: Nav::Stay,
+                    node_type: None,
+                    node_field: None,
+                    pre_effects: vec![],
+                    neg_fields: vec![],
+                    post_effects: end_effects,
+                    successors: vec![exit],
+                }));
+
+                // Compile body with variant's scope (no outer capture - it's on EndEnum)
+                let body_entry = if let Some(&payload_type_id) = variant_types.get(variant_idx) {
+                    self.with_scope(payload_type_id, |this| {
+                        this.compile_expr_inner(&body, ende_step, first_nav, CaptureEffects::default())
+                    })
+                } else {
+                    self.compile_expr_inner(&body, ende_step, first_nav, CaptureEffects::default())
+                };
+
+                // Create deferred member reference for the enum variant
+                let e_effect = if let Some(type_id) = alt_type_id {
+                    EffectIR::with_member(EffectOpcode::Enum, MemberRef::deferred(type_id, variant_idx as u16))
+                } else {
+                    EffectIR::simple(EffectOpcode::Enum, variant_idx)
+                };
+
+                let e_step = self.fresh_label();
+                self.instructions.push(Instruction::Match(MatchIR {
+                    label: e_step,
+                    nav: Nav::Stay,
+                    node_type: None,
+                    node_field: None,
+                    pre_effects: vec![e_effect],
+                    neg_fields: vec![],
+                    post_effects: vec![],
+                    successors: vec![body_entry],
+                }));
+
+                successors.push(e_step);
+            } else {
+                // Untagged branch: compile body, then inject Null for missing captures
+                let branch_entry = self.compile_expr_inner(&body, exit, first_nav, capture.clone());
+
+                let Some(fields) = merged_fields else {
+                    successors.push(branch_entry);
+                    continue;
+                };
+                let Some(type_id) = alt_type_id else {
+                    successors.push(branch_entry);
+                    continue;
+                };
+
+                // Build Null effects for fields not captured by this branch
+                let branch_captures = Self::collect_captures(&body);
+                let null_effects: Vec<_> = fields
+                    .iter()
+                    .enumerate()
+                    .filter(|&(_, (&sym, _))| !branch_captures.contains(self.interner.resolve(sym)))
+                    .flat_map(|(idx, _)| {
+                        [
+                            EffectIR::simple(EffectOpcode::Null, 0),
+                            EffectIR::with_member(EffectOpcode::Set, MemberRef::deferred(type_id, idx as u16)),
+                        ]
+                    })
+                    .collect();
+
+                if null_effects.is_empty() {
+                    successors.push(branch_entry);
+                    continue;
+                }
+
+                let null_step = self.fresh_label();
+                self.instructions.push(Instruction::Match(MatchIR {
+                    label: null_step,
+                    nav: Nav::Stay,
+                    node_type: None,
+                    node_field: None,
+                    pre_effects: null_effects,
+                    neg_fields: vec![],
+                    post_effects: vec![],
+                    successors: vec![branch_entry],
+                }));
+                successors.push(null_step);
+            }
+        }
+
+        if successors.is_empty() {
+            return exit;
+        }
+        if successors.len() == 1 {
+            return successors[0];
+        }
+
+        // Emit epsilon branch to choose among alternatives
+        let entry = self.fresh_label();
+        self.emit_epsilon(entry, successors);
+        entry
+    }
+}