diff --git a/crates/plotnik-lib/src/bytecode/ir.rs b/crates/plotnik-lib/src/bytecode/ir.rs
index e42485dc..8a7b624c 100644
--- a/crates/plotnik-lib/src/bytecode/ir.rs
+++ b/crates/plotnik-lib/src/bytecode/ir.rs
@@ -2,14 +2,16 @@
 //!
 //! Pre-layout instructions use `Label` for symbolic references.
 //! After layout, labels are resolved to `StepId` for serialization.
+//! Member indices use deferred resolution via `MemberRef`.
 
 use std::collections::BTreeMap;
 use std::num::NonZeroU16;
 
-use super::effects::EffectOp;
+use super::effects::{EffectOp, EffectOpcode};
 use super::ids::StepId;
 use super::instructions::{Call, Match, Return, select_match_opcode};
 use super::nav::Nav;
+use crate::query::type_check::TypeId;
 
 /// Symbolic reference, resolved to StepId at layout time.
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
@@ -34,6 +36,77 @@ impl Label {
     }
 }
 
+/// Symbolic reference to a struct field or enum variant.
+/// Resolved to absolute member index during bytecode emission.
+#[derive(Clone, Copy, Debug)]
+pub enum MemberRef {
+    /// Already resolved to absolute index (for cases where it's known).
+    Absolute(u16),
+    /// Deferred resolution: (struct/enum type, relative field/variant index).
+    Deferred { type_id: TypeId, relative_index: u16 },
+}
+
+impl MemberRef {
+    /// Create an absolute reference.
+    pub fn absolute(index: u16) -> Self {
+        Self::Absolute(index)
+    }
+
+    /// Create a deferred reference.
+    pub fn deferred(type_id: TypeId, relative_index: u16) -> Self {
+        Self::Deferred { type_id, relative_index }
+    }
+
+    /// Resolve this reference using a member base lookup function.
+    pub fn resolve<F>(self, get_member_base: F) -> u16
+    where
+        F: Fn(TypeId) -> Option<u16>,
+    {
+        match self {
+            Self::Absolute(n) => n,
+            Self::Deferred { type_id, relative_index } => {
+                get_member_base(type_id).unwrap_or(0) + relative_index
+            }
+        }
+    }
+}
+
+/// Effect operation with symbolic member references.
+/// Used during compilation; resolved to EffectOp during emission.
+#[derive(Clone, Debug)]
+pub struct EffectIR {
+    pub opcode: EffectOpcode,
+    /// Payload for effects that don't use member indices.
+    pub payload: usize,
+    /// Member reference for Set/E effects (None for other effects).
+    pub member_ref: Option<MemberRef>,
+}
+
+impl EffectIR {
+    /// Create a simple effect without member reference.
+    pub fn simple(opcode: EffectOpcode, payload: usize) -> Self {
+        Self { opcode, payload, member_ref: None }
+    }
+
+    /// Create an effect with a member reference.
+    pub fn with_member(opcode: EffectOpcode, member_ref: MemberRef) -> Self {
+        Self { opcode, payload: 0, member_ref: Some(member_ref) }
+    }
+
+    /// Resolve this IR effect to a concrete EffectOp.
+    pub fn resolve<F>(&self, get_member_base: F) -> EffectOp
+    where
+        F: Fn(TypeId) -> Option<u16>,
+    {
+        let payload = if let Some(member_ref) = self.member_ref {
+            member_ref.resolve(&get_member_base) as usize
+        } else {
+            self.payload
+        };
+        EffectOp { opcode: self.opcode, payload }
+    }
+}
+
 /// Pre-layout instruction with symbolic references.
 #[derive(Clone, Debug)]
 pub enum Instruction {
@@ -71,9 +144,12 @@ impl Instruction {
     }
 
     /// Resolve labels and serialize to bytecode bytes.
-    pub fn resolve(&self, map: &BTreeMap<Label, StepId>) -> Vec<u8> {
+    pub fn resolve<F>(&self, map: &BTreeMap<Label, StepId>, get_member_base: F) -> Vec<u8>
+    where
+        F: Fn(TypeId) -> Option<u16>,
+    {
         match self {
-            Self::Match(m) => m.resolve(map),
+            Self::Match(m) => m.resolve(map, get_member_base),
             Self::Call(c) => c.resolve(map).to_vec(),
             Self::Return(r) => r.resolve().to_vec(),
         }
@@ -92,11 +168,11 @@ pub struct MatchIR {
     /// Field constraint (None = wildcard).
     pub node_field: Option<NonZeroU16>,
     /// Effects to execute before match attempt.
-    pub pre_effects: Vec<EffectOp>,
+    pub pre_effects: Vec<EffectIR>,
     /// Fields that must NOT be present on the node.
     pub neg_fields: Vec<u16>,
     /// Effects to execute after successful match.
-    pub post_effects: Vec<EffectOp>,
+    pub post_effects: Vec<EffectIR>,
     /// Successor labels (empty = accept, 1 = linear, 2+ = branch).
     pub successors: Vec<Label>,
 }
@@ -126,17 +202,32 @@ impl MatchIR {
     }
 
     /// Resolve labels and serialize to bytecode bytes.
-    pub fn resolve(&self, map: &BTreeMap<Label, StepId>) -> Vec<u8> {
+    pub fn resolve<F>(&self, map: &BTreeMap<Label, StepId>, get_member_base: F) -> Vec<u8>
+    where
+        F: Fn(TypeId) -> Option<u16>,
+    {
         let successors: Vec<StepId> = self.successors.iter().map(|&l| l.resolve(map)).collect();
 
+        // Resolve effect member references to absolute indices
+        let pre_effects: Vec<EffectOp> = self
+            .pre_effects
+            .iter()
+            .map(|e| e.resolve(&get_member_base))
+            .collect();
+        let post_effects: Vec<EffectOp> = self
+            .post_effects
+            .iter()
+            .map(|e| e.resolve(&get_member_base))
+            .collect();
+
         let m = Match {
             segment: 0,
             nav: self.nav,
             node_type: self.node_type,
             node_field: self.node_field,
-            pre_effects: self.pre_effects.clone(),
+            pre_effects,
             neg_fields: self.neg_fields.clone(),
-            post_effects: self.post_effects.clone(),
+            post_effects,
             successors,
         };
 
@@ -240,15 +331,9 @@ mod tests {
             nav: Nav::Down,
             node_type: NonZeroU16::new(10),
             node_field: None,
-            pre_effects: vec![EffectOp {
-                opcode: super::super::effects::EffectOpcode::S,
-                payload: 0,
-            }],
+            pre_effects: vec![EffectIR::simple(EffectOpcode::S, 0)],
             neg_fields: vec![],
-            post_effects: vec![EffectOp {
-                opcode: super::super::effects::EffectOpcode::Node,
-                payload: 0,
-            }],
+            post_effects: vec![EffectIR::simple(EffectOpcode::Node, 0)],
             successors: vec![Label(1)],
         };
 
@@ -304,7 +389,7 @@ mod tests {
         let mut map = BTreeMap::new();
         map.insert(Label(0), StepId(1));
 
-        let bytes = m.resolve(&map);
+        let bytes = m.resolve(&map, |_| None);
         assert_eq!(bytes.len(), 8);
 
         // Verify opcode is Match8 (0x0)
@@ -312,4 +397,36 @@ mod tests {
         // Verify next is ACCEPT (0)
         assert_eq!(u16::from_le_bytes([bytes[6], bytes[7]]), 0);
     }
+
+    #[test]
+    fn member_ref_resolution() {
+        // Test absolute reference
+        let abs = MemberRef::absolute(42);
+        assert_eq!(abs.resolve(|_| None), 42);
+
+        // Test deferred reference with base lookup
+        let deferred = MemberRef::deferred(TypeId(10), 2);
+        assert_eq!(deferred.resolve(|id| if id.0 == 10 { Some(100) } else { None }), 102);
+
+        // Test deferred reference with no base (defaults to 0)
+        assert_eq!(deferred.resolve(|_| None), 2);
+    }
+
+    #[test]
+    fn effect_ir_resolution() {
+        // Simple effect without member ref
+        let simple = EffectIR::simple(EffectOpcode::Node, 5);
+        let resolved = simple.resolve(|_| None);
+        assert_eq!(resolved.opcode, EffectOpcode::Node);
+        assert_eq!(resolved.payload, 5);
+
+        // Effect with deferred member ref
+        let set_effect = EffectIR::with_member(
+            EffectOpcode::Set,
+            MemberRef::deferred(TypeId(10), 1),
+        );
+        let resolved = set_effect.resolve(|id| if id.0 == 10 { Some(50) } else { None });
+        assert_eq!(resolved.opcode, EffectOpcode::Set);
+        assert_eq!(resolved.payload, 51); // base 50 + relative 1
+    }
 }
diff --git a/crates/plotnik-lib/src/bytecode/layout_tests.rs b/crates/plotnik-lib/src/bytecode/layout_tests.rs
index d2e4543f..b1741b43 100644
--- a/crates/plotnik-lib/src/bytecode/layout_tests.rs
+++ b/crates/plotnik-lib/src/bytecode/layout_tests.rs
@@ -1,9 +1,9 @@
 use std::num::NonZeroU16;
 
 use super::ids::StepId;
-use super::ir::{CallIR, Instruction, Label, MatchIR, ReturnIR};
+use super::ir::{CallIR, EffectIR, Instruction, Label, MatchIR, ReturnIR};
 use super::layout::CacheAligned;
-use crate::bytecode::effects::{EffectOp, EffectOpcode};
+use crate::bytecode::effects::EffectOpcode;
 use crate::bytecode::nav::Nav;
 
 #[test]
@@ -191,16 +191,16 @@ fn layout_large_instruction_cache_alignment() {
         node_type: NonZeroU16::new(10),
         node_field: None,
         pre_effects: vec![
-            EffectOp { opcode: EffectOpcode::S, payload: 0 },
-            EffectOp { opcode: EffectOpcode::S, payload: 0 },
-            EffectOp { opcode: EffectOpcode::S, payload: 0 },
+            EffectIR::simple(EffectOpcode::S, 0),
+            EffectIR::simple(EffectOpcode::S, 0),
+            EffectIR::simple(EffectOpcode::S, 0),
         ],
         neg_fields: vec![],
         post_effects: vec![
-            EffectOp { opcode: EffectOpcode::Node, payload: 0 },
-            EffectOp { opcode: EffectOpcode::EndS, payload: 0 },
-            EffectOp { opcode: EffectOpcode::EndS, payload: 0 },
-            EffectOp { opcode: EffectOpcode::EndS, payload: 0 },
+            EffectIR::simple(EffectOpcode::Node, 0),
+            EffectIR::simple(EffectOpcode::EndS, 0),
+            EffectIR::simple(EffectOpcode::EndS, 0),
+            EffectIR::simple(EffectOpcode::EndS, 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 69ea7eae..e47598e5 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
@@ -67,15 +67,15 @@ Assignment:
   09  *↓   (assignment_expression)          10
   10   𝜀   left: _                          11
   11  *↓   (identifier)                     12
-  12   𝜀   [Node Set(M1)]                   14
+  12   𝜀   [Node Set(M6)]                   14
   14   𝜀   right: _                         ▶(Expression)
-  15   𝜀   [Node Set(M0)]                   17
+  15   𝜀   [Node Set(M5)]                   17
   17  *↑¹                                   ◼
   18   𝜀   [EndE]                           ◼
-  20   𝜀   [Node]                           18
+  20   𝜀   [Node Set(M1)]                   18
   22  *↓   (number)                         20
-  23   𝜀   [E(M0)]                          22
+  23   𝜀   [E(M3)]                          22
   25   𝜀   [EndE]                           ◼
-  27   𝜀   [Node]                           25
+  27   𝜀   [Node Set(M2)]                   25
   29  *↓   (identifier)                     27
-  30   𝜀   [E(M1)]                          29
+  30   𝜀   [E(M4)]                          29
diff --git a/crates/plotnik-lib/src/query/codegen.rs b/crates/plotnik-lib/src/query/codegen.rs
index 2c2cbde7..3f6067a6 100644
--- a/crates/plotnik-lib/src/query/codegen.rs
+++ b/crates/plotnik-lib/src/query/codegen.rs
@@ -452,6 +452,24 @@ impl TypeTableBuilder {
         self.mapping.get(&type_id).copied()
     }
 
+    /// Get the absolute member base index for a struct/enum type.
+    ///
+    /// For Struct and Enum types, returns the starting index in the TypeMembers table.
+    /// Fields/variants are at indices [base..base+count).
+    pub fn get_member_base(&self, type_id: TypeId) -> Option<u16> {
+        let bc_type_id = self.mapping.get(&type_id)?;
+        let slot_index = bc_type_id.custom_index()?;
+        let type_def = self.type_defs.get(slot_index)?;
+
+        // Only Struct and Enum have member bases
+        let kind = TypeKind::from_u8(type_def.kind)?;
+        if kind.is_composite() {
+            Some(type_def.data)
+        } else {
+            None
+        }
+    }
+
     /// Emit type definitions, members, and names as bytes.
     ///
     /// Returns (type_defs_bytes, type_members_bytes, type_names_bytes).
@@ -671,7 +689,7 @@ fn emit_inner(
     let trivia_entries: Vec<TriviaEntry> = Vec::new();
 
     // Resolve and serialize transitions
-    let transitions_bytes = emit_transitions(&compile_result.instructions, &layout);
+    let transitions_bytes = emit_transitions(&compile_result.instructions, &layout, &types);
 
     // Emit all byte sections
     let (str_blob, str_table) = strings.emit();
@@ -742,10 +760,14 @@ fn emit_inner(
 fn emit_transitions(
     instructions: &[crate::bytecode::ir::Instruction],
     layout: &crate::bytecode::ir::LayoutResult,
+    types: &TypeTableBuilder,
 ) -> Vec<u8> {
     // Allocate buffer for all steps (8 bytes each)
     let mut bytes = vec![0u8; layout.total_steps as usize * 8];
 
+    // Create a resolver closure for member indices
+    let get_member_base = |type_id: TypeId| types.get_member_base(type_id);
+
     for instr in instructions {
         let label = instr.label();
         let Some(&step_id) = layout.label_to_step.get(&label) else {
@@ -753,7 +775,7 @@ fn emit_transitions(
         };
 
         let offset = step_id.byte_offset();
-        let resolved = instr.resolve(&layout.label_to_step);
+        let resolved = instr.resolve(&layout.label_to_step, get_member_base);
 
         // Copy instruction bytes to the correct position
         let end = offset + resolved.len();
diff --git a/crates/plotnik-lib/src/query/compile.rs b/crates/plotnik-lib/src/query/compile.rs
index a99fe385..7b463207 100644
--- a/crates/plotnik-lib/src/query/compile.rs
+++ b/crates/plotnik-lib/src/query/compile.rs
@@ -2,20 +2,21 @@
 //!
 //! 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, Instruction, Label, MatchIR, ReturnIR};
-use crate::bytecode::{EffectOp, EffectOpcode, Nav};
+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, TypeShape};
+use super::type_check::{Arity, DefId, TypeContext, TypeId, TypeShape};
 
 /// Error during compilation.
 #[derive(Clone, Debug)]
@@ -46,6 +47,11 @@ pub struct CompileResult {
     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,
@@ -58,8 +64,9 @@ pub struct Compiler<'a> {
     next_label_id: u32,
     def_entries: IndexMap<DefId, Label>,
     ref_id_counter: u16,
-    /// Currently compiling definition (for member index lookup).
-    current_def_id: Option<DefId>,
+    /// Stack of active struct scopes for capture lookup.
+    /// Innermost scope is at the end.
+    scope_stack: Vec<StructScope>,
 }
 
 impl<'a> Compiler<'a> {
@@ -83,7 +90,7 @@ impl<'a> Compiler<'a> {
             next_label_id: 0,
             def_entries: IndexMap::new(),
             ref_id_counter: 0,
-            current_def_id: None,
+            scope_stack: Vec::new(),
         }
     }
 
@@ -140,18 +147,18 @@ impl<'a> Compiler<'a> {
 
         let entry_label = self.def_entries[&def_id];
 
-        // Track current definition for member index lookup
-        self.current_def_id = Some(def_id);
-
-        // Compile body, targeting accept state
-        let body_entry = self.compile_expr(body, Label::ACCEPT);
+        // 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]);
         }
 
-        self.current_def_id = None;
         Ok(())
     }
 
@@ -494,15 +501,32 @@ impl<'a> Compiler<'a> {
             return exit;
         }
 
-        // Check if this is a tagged alternation (Enum type)
+        // Check if this is a tagged alternation (Enum type) and get type_id
         let alt_expr = Expr::AltExpr(alt.clone());
-        let is_enum = self
+        let enum_type_id = self
             .type_ctx
             .get_term_info(&alt_expr)
-            .and_then(|info| info.flow.type_id())
+            .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();
@@ -512,7 +536,7 @@ impl<'a> Compiler<'a> {
             };
 
             if is_enum {
-                // Tagged branch: E(variant_idx) → body → EndE → exit
+                // Tagged branch: E(variant_ref) → body → EndE → exit
                 let ende_step = self.fresh_label();
                 self.instructions.push(Instruction::Match(MatchIR {
                     label: ende_step,
@@ -521,14 +545,25 @@ impl<'a> Compiler<'a> {
                     node_field: None,
                     pre_effects: vec![],
                     neg_fields: vec![],
-                    post_effects: vec![EffectOp {
-                        opcode: EffectOpcode::EndE,
-                        payload: 0,
-                    }],
+                    post_effects: vec![EffectIR::simple(EffectOpcode::EndE, 0)],
                     successors: vec![exit],
                 }));
 
-                let body_entry = self.compile_expr_with_nav(&body, ende_step, first_nav);
+                // 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 {
@@ -536,10 +571,7 @@ impl<'a> Compiler<'a> {
                     nav: Nav::Stay,
                     node_type: None,
                     node_field: None,
-                    pre_effects: vec![EffectOp {
-                        opcode: EffectOpcode::E,
-                        payload: variant_idx,
-                    }],
+                    pre_effects: vec![e_effect],
                     neg_fields: vec![],
                     post_effects: vec![],
                     successors: vec![body_entry],
@@ -712,33 +744,55 @@ impl<'a> Compiler<'a> {
             t.name().map(|n| n.text() == "string").unwrap_or(false)
         });
 
-        // Build capture effects: Node/Text followed by Set(member_index)
-        let mut capture_effects = Vec::with_capacity(2);
+        // 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 {
-            EffectOp { opcode: EffectOpcode::Text, payload: 0 }
+            EffectIR::simple(EffectOpcode::Text, 0)
         } else {
-            EffectOp { opcode: EffectOpcode::Node, payload: 0 }
+            EffectIR::simple(EffectOpcode::Node, 0)
         };
         capture_effects.push(capture_effect);
 
-        // Add Set effect if we can resolve the member index
-        if let Some(name_token) = cap.name()
-            && let Some(member_idx) = self.lookup_member_index(name_token.text())
-        {
-            capture_effects.push(EffectOp {
-                opcode: EffectOpcode::Set,
-                payload: member_idx as usize,
-            });
+        // 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));
+            }
         }
 
-        // 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.map(|info| info.flow.is_bubble()).unwrap_or(false);
-
         // 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))
@@ -764,10 +818,7 @@ impl<'a> Compiler<'a> {
 
             if inner_is_bubble {
                 // Struct scope: S → inner → EndS + capture_effects → exit
-                let mut post_effects = vec![EffectOp {
-                    opcode: EffectOpcode::EndS,
-                    payload: 0,
-                }];
+                let mut post_effects = vec![EffectIR::simple(EffectOpcode::EndS, 0)];
                 post_effects.extend(capture_effects);
 
                 self.instructions.push(Instruction::Match(MatchIR {
@@ -781,7 +832,14 @@ impl<'a> Compiler<'a> {
                     successors: vec![exit],
                 }));
 
-                let inner_entry = self.compile_expr_with_nav(&inner, effect_label, nav_override);
+                // 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();
@@ -790,10 +848,7 @@ impl<'a> Compiler<'a> {
                     nav: Nav::Stay,
                     node_type: None,
                     node_field: None,
-                    pre_effects: vec![EffectOp {
-                        opcode: EffectOpcode::S,
-                        payload: 0,
-                    }],
+                    pre_effects: vec![EffectIR::simple(EffectOpcode::S, 0)],
                     neg_fields: vec![],
                     post_effects: vec![],
                     successors: vec![inner_entry],
@@ -802,10 +857,7 @@ impl<'a> Compiler<'a> {
                 s_step
             } else if inner_is_many {
                 // Array: A → quantifier (with Push) → EndA + capture_effects → exit
-                let mut post_effects = vec![EffectOp {
-                    opcode: EffectOpcode::EndA,
-                    payload: 0,
-                }];
+                let mut post_effects = vec![EffectIR::simple(EffectOpcode::EndA, 0)];
                 post_effects.extend(capture_effects);
 
                 self.instructions.push(Instruction::Match(MatchIR {
@@ -833,10 +885,7 @@ impl<'a> Compiler<'a> {
                     nav: Nav::Stay,
                     node_type: None,
                     node_field: None,
-                    pre_effects: vec![EffectOp {
-                        opcode: EffectOpcode::A,
-                        payload: 0,
-                    }],
+                    pre_effects: vec![EffectIR::simple(EffectOpcode::A, 0)],
                     neg_fields: vec![],
                     post_effects: vec![],
                     successors: vec![inner_entry],
@@ -897,6 +946,10 @@ impl<'a> Compiler<'a> {
             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 {
@@ -906,21 +959,26 @@ impl<'a> Compiler<'a> {
             node_field: None,
             pre_effects: vec![],
             neg_fields: vec![],
-            post_effects: vec![EffectOp {
-                opcode: EffectOpcode::Push,
-                payload: 0,
-            }],
+            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();
 
-            // Bodies target push_step
-            let first_body_entry = self.compile_expr_with_nav(&inner, push_step, nav_override);
-            let repeat_body_entry = self.compile_expr(&inner, push_step);
+            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] {
@@ -940,9 +998,8 @@ impl<'a> Compiler<'a> {
             // *: entry → [first_body → push → loop_entry → [repeat_body → push, exit], exit]
             let loop_entry = self.fresh_label();
 
-            // Bodies target push_step
-            let first_body_entry = self.compile_expr_with_nav(&inner, push_step, nav_override);
-            let repeat_body_entry = self.compile_expr(&inner, push_step);
+            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] {
@@ -969,7 +1026,8 @@ impl<'a> Compiler<'a> {
             entry
         } else {
             // ?: branch to body or exit (no Push needed for optional)
-            let body_entry = self.compile_expr_with_nav(&inner, exit, nav_override);
+            let body_entry = compile_with_row_scope(self, exit, nav_override);
+
             let entry = self.fresh_label();
 
             let successors = if is_greedy {
@@ -1091,24 +1149,42 @@ impl<'a> Compiler<'a> {
             .collect()
     }
 
-    /// Look up a capture name's member index in the current definition's type.
-    ///
-    /// Returns the position (0-based) of the field in the struct's BTreeMap order,
-    /// or None if not found or not in a struct context.
-    fn lookup_member_index(&self, capture_name: &str) -> Option<u16> {
-        let def_id = self.current_def_id?;
-        let type_id = self.type_ctx.get_def_type(def_id)?;
-        let fields = self.type_ctx.get_struct_fields(type_id)?;
+    /// 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
+    }
 
-        // BTreeMap iterates in key order (Symbol order)
-        for (index, (&sym, _)) in fields.iter().enumerate() {
+    /// 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(index as u16);
+                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)]