From a84dfb0d15f4593b612725a23a2eafc5f5861cd9 Mon Sep 17 00:00:00 2001
From: Sergei Zharinov <zharinov@users.noreply.github.com>
Date: Thu, 15 Jan 2026 12:36:07 -0300
Subject: [PATCH] refactor: Epsilon elimination with semantic fingerprint
 verification

---
 .github/workflows/sync-langs.yml              |   2 +-
 AGENTS.md                                     |  55 +-
 .../src/bytecode/aligned_vec.rs               |   5 +-
 .../src/bytecode/aligned_vec_tests.rs         |   2 +-
 crates/plotnik-bytecode/src/bytecode/dump.rs  |   5 +-
 .../src/bytecode/header_tests.rs              |  36 +-
 .../plotnik-bytecode/src/bytecode/module.rs   |   5 +-
 .../src/bytecode/module_tests.rs              |   2 +-
 crates/plotnik-bytecode/src/lib.rs            |  13 +-
 crates/plotnik-cli/src/commands/exec.rs       |   4 +-
 .../src/analyze/validation/predicates.rs      |  30 +-
 crates/plotnik-compiler/src/bytecode/ir.rs    |   7 +-
 .../plotnik-compiler/src/compile/capture.rs   |  16 +-
 .../src/compile/capture_tests.rs              |   2 +-
 .../src/compile/compile_tests.rs              | 118 +--
 .../plotnik-compiler/src/compile/compiler.rs  | 141 ++--
 crates/plotnik-compiler/src/compile/dce.rs    | 135 +++
 .../src/compile/epsilon_elim.rs               | 786 ++++++++++++++++++
 .../src/compile/expressions.rs                |  36 +-
 crates/plotnik-compiler/src/compile/mod.rs    |   5 +-
 .../src/compile/navigation.rs                 |   2 +-
 .../src/compile/quantifier.rs                 |   6 +-
 crates/plotnik-compiler/src/compile/scope.rs  |   6 +-
 .../plotnik-compiler/src/compile/sequences.rs |  11 +-
 crates/plotnik-compiler/src/compile/verify.rs | 353 ++++++++
 .../src/diagnostics/message.rs                |   9 +-
 crates/plotnik-compiler/src/emit/emitter.rs   |  47 +-
 .../plotnik-compiler/src/emit/layout_tests.rs |   2 +-
 crates/plotnik-compiler/src/emit/mod.rs       |   6 +-
 .../src/emit/regex_table_tests.rs             |  32 +-
 ...it__emit_tests__alternations_captured.snap |  10 +-
 ...t_tests__alternations_captured_tagged.snap |  11 +-
 ...mit_tests__alternations_in_quantifier.snap |  41 +-
 ...mit__emit_tests__alternations_labeled.snap |  12 +-
 ...ts__alternations_no_internal_captures.snap |  12 +-
 ...it_tests__alternations_null_injection.snap |  12 +-
 ...ternations_tagged_in_field_constraint.snap |  16 +-
 ...ternations_tagged_with_definition_ref.snap |  28 +-
 ...t__emit_tests__alternations_unlabeled.snap |  12 +-
 ..._emit_tests__anchors_between_siblings.snap |  11 +-
 ...emit__emit_tests__anchors_first_child.snap |  19 +-
 ..._emit__emit_tests__anchors_last_child.snap |  15 +-
 ...__emit__emit_tests__anchors_no_anchor.snap |  11 +-
 ...t__emit_tests__anchors_with_anonymous.snap |  11 +-
 ...ler__emit__emit_tests__captures_basic.snap |  16 +-
 ...t__emit_tests__captures_deeply_nested.snap |  16 +-
 ...s__captures_enum_with_type_annotation.snap |  11 +-
 ...__emit__emit_tests__captures_multiple.snap |   4 +-
 ...mit__emit_tests__captures_nested_flat.snap |  14 +-
 ...sts__captures_optional_wrapper_struct.snap |  22 +-
 ...it__emit_tests__captures_struct_scope.snap |  10 +-
 ..._captures_struct_with_type_annotation.snap |  12 +-
 ...emit_tests__captures_with_type_custom.snap |  16 +-
 ...emit_tests__captures_with_type_string.snap |  16 +-
 ...__emit_tests__captures_wrapper_struct.snap |  34 +-
 ...tests__comprehensive_multi_definition.snap |  33 +-
 ...mit__emit_tests__definitions_multiple.snap |  13 +-
 ...mit_tests__definitions_nested_capture.snap |  43 +-
 ...it__emit_tests__definitions_reference.snap |  23 +-
 ..._emit__emit_tests__definitions_single.snap |  16 +-
 ..._emit__emit_tests__fields_alternation.snap |  14 +-
 ...er__emit__emit_tests__fields_multiple.snap |   4 +-
 ...ler__emit__emit_tests__fields_negated.snap |  10 +-
 ...iler__emit__emit_tests__fields_single.snap |   4 +-
 ...er__emit__emit_tests__nodes_anonymous.snap |   4 +-
 ...mpiler__emit__emit_tests__nodes_error.snap |  16 +-
 ...iler__emit__emit_tests__nodes_missing.snap |  16 +-
 ...mpiler__emit__emit_tests__nodes_named.snap |  16 +-
 ..._emit__emit_tests__nodes_wildcard_any.snap |   4 +-
 ...mit__emit_tests__nodes_wildcard_named.snap |   4 +-
 ...mit__emit_tests__optional_first_child.snap |  25 +-
 ...__emit_tests__optional_null_injection.snap |  20 +-
 ..._tests__quantifiers_first_child_array.snap |  36 +-
 ...mit__emit_tests__quantifiers_optional.snap |  20 +-
 ...tests__quantifiers_optional_nongreedy.snap |  20 +-
 ...r__emit__emit_tests__quantifiers_plus.snap |  22 +-
 ...mit_tests__quantifiers_plus_nongreedy.snap |  22 +-
 ..._tests__quantifiers_repeat_navigation.snap |  29 +-
 ...s__quantifiers_sequence_in_called_def.snap |  53 +-
 ...r__emit__emit_tests__quantifiers_star.snap |  25 +-
 ...mit_tests__quantifiers_star_nongreedy.snap |  25 +-
 ..._emit_tests__quantifiers_struct_array.snap |  38 +-
 ...r__emit__emit_tests__recursion_simple.snap |  19 +-
 ...sts__recursion_with_structured_result.snap |  28 +-
 ...er__emit__emit_tests__sequences_basic.snap |  11 +-
 ...__emit_tests__sequences_in_quantifier.snap |  33 +-
 ...r__emit__emit_tests__sequences_nested.snap |  15 +-
 ...__emit_tests__sequences_with_captures.snap |   4 +-
 crates/plotnik-compiler/src/parser/lexer.rs   |   7 +-
 .../src/typegen/typescript/naming.rs          |   5 +-
 crates/plotnik-lib/src/lib.rs                 |   4 +-
 crates/plotnik-vm/src/engine/verify.rs        |   2 +-
 crates/plotnik-vm/src/engine/vm.rs            |   9 +-
 docs/binary-format/01-overview.md             |  30 +-
 docs/binary-format/03-symbols.md              |   1 +
 docs/binary-format/04-types.md                |  46 +-
 docs/binary-format/06-transitions.md          |  32 +-
 97 files changed, 2058 insertions(+), 1014 deletions(-)
 create mode 100644 crates/plotnik-compiler/src/compile/dce.rs
 create mode 100644 crates/plotnik-compiler/src/compile/epsilon_elim.rs
 create mode 100644 crates/plotnik-compiler/src/compile/verify.rs

diff --git a/.github/workflows/sync-langs.yml b/.github/workflows/sync-langs.yml
index 2768ac8..913cb93 100644
--- a/.github/workflows/sync-langs.yml
+++ b/.github/workflows/sync-langs.yml
@@ -3,7 +3,7 @@ name: Sync arborium languages
 on:
   push:
     branches:
-      - 'renovate/arborium-crates'
+      - "renovate/arborium-crates"
 
 permissions:
   contents: write
diff --git a/AGENTS.md b/AGENTS.md
index 48ba8d5..c61b728 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -12,26 +12,26 @@
 
 ## Core Constructs
 
-| Syntax              | Meaning                        |
-| ------------------- | ------------------------------ |
-| `(node_kind)`       | Named node                     |
-| `"text"` / `'text'` | Anonymous node (literal token) |
-| `(_)`               | Any named node                 |
-| `_`                 | Any node                       |
-| `@name`             | Capture (snake_case only)      |
-| `@x :: T`           | Type annotation                |
-| `@x :: string`      | Extract node text              |
-| `field: pattern`    | Field constraint               |
-| `-field`            | Negated field (assert absent)  |
-| `?` `*` `+`         | Quantifiers (0-1, 0+, 1+)      |
-| `??` `*?` `+?`      | Non-greedy variants            |
-| `.`                 | Anchor (adjacency, see below)  |
-| `{...}`             | Sequence (siblings in order)   |
-| `[...]`             | Alternation (first match wins) |
-| `Name = ...`        | Named definition (entrypoint)  |
-| `(Name)`            | Use named expression           |
-| `(node == "x")`     | String predicate (== != ^= $= *=) |
-| `(node =~ /x/)`     | Regex predicate (=~ !~)        |
+| Syntax              | Meaning                            |
+| ------------------- | ---------------------------------- |
+| `(node_kind)`       | Named node                         |
+| `"text"` / `'text'` | Anonymous node (literal token)     |
+| `(_)`               | Any named node                     |
+| `_`                 | Any node                           |
+| `@name`             | Capture (snake_case only)          |
+| `@x :: T`           | Type annotation                    |
+| `@x :: string`      | Extract node text                  |
+| `field: pattern`    | Field constraint                   |
+| `-field`            | Negated field (assert absent)      |
+| `?` `*` `+`         | Quantifiers (0-1, 0+, 1+)          |
+| `??` `*?` `+?`      | Non-greedy variants                |
+| `.`                 | Anchor (adjacency, see below)      |
+| `{...}`             | Sequence (siblings in order)       |
+| `[...]`             | Alternation (first match wins)     |
+| `Name = ...`        | Named definition (entrypoint)      |
+| `(Name)`            | Use named expression               |
+| `(node == "x")`     | String predicate (== != ^= $= \*=) |
+| `(node =~ /x/)`     | Regex predicate (=~ !~)            |
 
 ## Data Model Rules
 
@@ -148,23 +148,26 @@ Tree-sitter: `((a) (b))` — Plotnik: `{(a) (b)}`. The #1 syntax error.
 
 ```
 crates/
+  plotnik-bytecode/    # Binary format definitions
+    src/
+      bytecode/        # Instruction set, modules, linking
+      type_system/     # Shared type primitives
   plotnik-cli/         # CLI tool
     src/commands/      # Subcommands (ast, check, dump, exec, infer, trace, langs)
-  plotnik-core/        # Node type database (NodeTypes, StaticNodeTypes) and string interning (Interner, Symbol)
-  plotnik-lib/         # Plotnik as library
+  plotnik-compiler/    # Compilation pipeline
     src/
       analyze/         # Semantic analysis (symbol_table, dependencies, type_check, validation)
-      bytecode/        # Binary format definitions
       compile/         # Thompson NFA construction (AST → IR)
       diagnostics/     # User-friendly error reporting
       emit/            # Bytecode emission (IR → binary)
-      engine/          # Runtime VM (execution, backtracking, effects)
       parser/          # Syntactic parsing (lexer, grammar, AST)
       query/           # Query facade (Query, QueryBuilder, SourceMap)
-      type_system/     # Shared type primitives
       typegen/         # Type declaration extraction (bytecode → .d.ts)
+  plotnik-core/        # Node type database (NodeTypes, StaticNodeTypes) and string interning (Interner, Symbol)
   plotnik-langs/       # Tree-sitter language bindings
-  plotnik-macros/      # Proc macros
+  plotnik-lib/         # Facade crate re-exporting bytecode, compiler, vm
+  plotnik-vm/          # Runtime VM
+    src/engine/        # Execution, backtracking, effects
 docs/
   binary-format/       # Bytecode format specification
   lang-reference.md    # Language specification
diff --git a/crates/plotnik-bytecode/src/bytecode/aligned_vec.rs b/crates/plotnik-bytecode/src/bytecode/aligned_vec.rs
index ca7aa82..c5d92fb 100644
--- a/crates/plotnik-bytecode/src/bytecode/aligned_vec.rs
+++ b/crates/plotnik-bytecode/src/bytecode/aligned_vec.rs
@@ -102,7 +102,10 @@ impl std::fmt::Debug for AlignedVec {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("AlignedVec")
             .field("len", &self.len)
-            .field("aligned", &(self.blocks.as_ptr() as usize).is_multiple_of(ALIGN))
+            .field(
+                "aligned",
+                &(self.blocks.as_ptr() as usize).is_multiple_of(ALIGN),
+            )
             .finish()
     }
 }
diff --git a/crates/plotnik-bytecode/src/bytecode/aligned_vec_tests.rs b/crates/plotnik-bytecode/src/bytecode/aligned_vec_tests.rs
index dc7650d..87b9842 100644
--- a/crates/plotnik-bytecode/src/bytecode/aligned_vec_tests.rs
+++ b/crates/plotnik-bytecode/src/bytecode/aligned_vec_tests.rs
@@ -1,4 +1,4 @@
-use super::aligned_vec::{AlignedVec, ALIGN};
+use super::aligned_vec::{ALIGN, AlignedVec};
 
 fn is_aligned(ptr: *const u8) -> bool {
     (ptr as usize).is_multiple_of(ALIGN)
diff --git a/crates/plotnik-bytecode/src/bytecode/dump.rs b/crates/plotnik-bytecode/src/bytecode/dump.rs
index c14b671..ecb0111 100644
--- a/crates/plotnik-bytecode/src/bytecode/dump.rs
+++ b/crates/plotnik-bytecode/src/bytecode/dump.rs
@@ -5,15 +5,15 @@
 use std::collections::BTreeMap;
 use std::fmt::Write as _;
 
-use plotnik_core::Colors;
 use crate::predicate_op::PredicateOp;
+use plotnik_core::Colors;
 
 use super::format::{LineBuilder, Symbol, format_effect, nav_symbol, width_for_count};
 use super::ids::TypeId;
 use super::instructions::StepId;
 use super::module::{Instruction, Module};
-use super::node_type_ir::NodeTypeIR;
 use super::nav::Nav;
+use super::node_type_ir::NodeTypeIR;
 use super::type_meta::{TypeData, TypeKind};
 use super::{Call, Match, Return, Trampoline};
 
@@ -32,7 +32,6 @@ pub fn dump(module: &Module, colors: Colors) -> String {
     out
 }
 
-
 /// Context for dump formatting, precomputes lookups for O(1) access.
 struct DumpContext {
     /// Maps step ID to entrypoint name for labeling.
diff --git a/crates/plotnik-bytecode/src/bytecode/header_tests.rs b/crates/plotnik-bytecode/src/bytecode/header_tests.rs
index fd88543..263adb2 100644
--- a/crates/plotnik-bytecode/src/bytecode/header_tests.rs
+++ b/crates/plotnik-bytecode/src/bytecode/header_tests.rs
@@ -49,12 +49,12 @@ fn compute_offsets_empty() {
 
     // New order: blobs first, then tables
     // All sections 64-byte aligned. With 0 counts, each table still has 1 sentinel entry (4 bytes)
-    assert_eq!(offsets.str_blob, 64);            // after header
-    assert_eq!(offsets.regex_blob, 64);          // 64 + align(0) = 64
-    assert_eq!(offsets.str_table, 64);           // 64 + align(0) = 64
-    assert_eq!(offsets.regex_table, 128);        // 64 + align(4) = 128
-    assert_eq!(offsets.node_types, 192);         // 128 + align(4) = 192
-    assert_eq!(offsets.node_fields, 192);        // 192 + align(0) = 192
+    assert_eq!(offsets.str_blob, 64); // after header
+    assert_eq!(offsets.regex_blob, 64); // 64 + align(0) = 64
+    assert_eq!(offsets.str_table, 64); // 64 + align(0) = 64
+    assert_eq!(offsets.regex_table, 128); // 64 + align(4) = 128
+    assert_eq!(offsets.node_types, 192); // 128 + align(4) = 192
+    assert_eq!(offsets.node_fields, 192); // 192 + align(0) = 192
     assert_eq!(offsets.trivia, 192);
     assert_eq!(offsets.type_defs, 192);
     assert_eq!(offsets.type_members, 192);
@@ -84,16 +84,16 @@ fn compute_offsets_with_data() {
     let offsets = h.compute_offsets();
 
     // New order: blobs first, then tables. All offsets 64-byte aligned.
-    assert_eq!(offsets.str_blob, 64);            // header end
-    assert_eq!(offsets.regex_blob, 192);         // 64 + 100 = 164 → 192
-    assert_eq!(offsets.str_table, 320);          // 192 + 128 = 320 (aligned)
-    assert_eq!(offsets.regex_table, 384);        // 320 + 24 = 344 → 384
-    assert_eq!(offsets.node_types, 448);         // 384 + 12 = 396 → 448
-    assert_eq!(offsets.node_fields, 512);        // 448 + 40 = 488 → 512
-    assert_eq!(offsets.trivia, 576);             // 512 + 20 = 532 → 576
-    assert_eq!(offsets.type_defs, 640);          // 576 + 6 = 582 → 640
-    assert_eq!(offsets.type_members, 704);       // 640 + 32 = 672 → 704
-    assert_eq!(offsets.type_names, 768);         // 704 + 48 = 752 → 768
-    assert_eq!(offsets.entrypoints, 832);        // 768 + 16 = 784 → 832
-    assert_eq!(offsets.transitions, 896);        // 832 + 16 = 848 → 896
+    assert_eq!(offsets.str_blob, 64); // header end
+    assert_eq!(offsets.regex_blob, 192); // 64 + 100 = 164 → 192
+    assert_eq!(offsets.str_table, 320); // 192 + 128 = 320 (aligned)
+    assert_eq!(offsets.regex_table, 384); // 320 + 24 = 344 → 384
+    assert_eq!(offsets.node_types, 448); // 384 + 12 = 396 → 448
+    assert_eq!(offsets.node_fields, 512); // 448 + 40 = 488 → 512
+    assert_eq!(offsets.trivia, 576); // 512 + 20 = 532 → 576
+    assert_eq!(offsets.type_defs, 640); // 576 + 6 = 582 → 640
+    assert_eq!(offsets.type_members, 704); // 640 + 32 = 672 → 704
+    assert_eq!(offsets.type_names, 768); // 704 + 48 = 752 → 768
+    assert_eq!(offsets.entrypoints, 832); // 768 + 16 = 784 → 832
+    assert_eq!(offsets.transitions, 896); // 832 + 16 = 848 → 896
 }
diff --git a/crates/plotnik-bytecode/src/bytecode/module.rs b/crates/plotnik-bytecode/src/bytecode/module.rs
index 554fb8d..08f4672 100644
--- a/crates/plotnik-bytecode/src/bytecode/module.rs
+++ b/crates/plotnik-bytecode/src/bytecode/module.rs
@@ -197,7 +197,10 @@ impl Module {
     }
 
     /// Load a module from owned bytes (copies into aligned storage).
-    #[deprecated(since = "0.1.0", note = "use `Module::from_aligned` for AlignedVec or `Module::load` for copying")]
+    #[deprecated(
+        since = "0.1.0",
+        note = "use `Module::from_aligned` for AlignedVec or `Module::load` for copying"
+    )]
     pub fn from_bytes(bytes: Vec<u8>) -> Result<Self, ModuleError> {
         Self::load(&bytes)
     }
diff --git a/crates/plotnik-bytecode/src/bytecode/module_tests.rs b/crates/plotnik-bytecode/src/bytecode/module_tests.rs
index 84b3100..1a4a6e3 100644
--- a/crates/plotnik-bytecode/src/bytecode/module_tests.rs
+++ b/crates/plotnik-bytecode/src/bytecode/module_tests.rs
@@ -1,7 +1,7 @@
 //! Tests for the bytecode module.
 
-use super::module::{ByteStorage, ModuleError};
 use super::AlignedVec;
+use super::module::{ByteStorage, ModuleError};
 
 #[test]
 fn byte_storage_copy_from_slice() {
diff --git a/crates/plotnik-bytecode/src/lib.rs b/crates/plotnik-bytecode/src/lib.rs
index 116a85b..771fa2e 100644
--- a/crates/plotnik-bytecode/src/lib.rs
+++ b/crates/plotnik-bytecode/src/lib.rs
@@ -15,13 +15,12 @@ pub mod type_system;
 // Re-export commonly used items at crate root
 pub use bytecode::{
     AlignedVec, ByteStorage, Call, EffectOp, EffectOpcode, Entrypoint, EntrypointsView,
-    FieldSymbol, Header, Instruction, LineBuilder, MAGIC, MAX_MATCH_PAYLOAD_SLOTS,
-    MAX_PRE_EFFECTS, Match, Module, ModuleError, Nav, NodeSymbol, NodeTypeIR, Opcode, RegexView,
-    Return, SECTION_ALIGN, STEP_SIZE, SectionOffsets, Slice, StepAddr, StepId, StringId,
-    StringsView, Symbol, SymbolsView, Trampoline, TriviaEntry, TriviaView, TypeData, TypeDef,
-    TypeId, TypeKind, TypeMember, TypeName, TypesView, VERSION, align_to_section, cols, dump,
-    format_effect, nav_symbol, select_match_opcode, superscript, trace, truncate_text,
-    width_for_count,
+    FieldSymbol, Header, Instruction, LineBuilder, MAGIC, MAX_MATCH_PAYLOAD_SLOTS, MAX_PRE_EFFECTS,
+    Match, Module, ModuleError, Nav, NodeSymbol, NodeTypeIR, Opcode, RegexView, Return,
+    SECTION_ALIGN, STEP_SIZE, SectionOffsets, Slice, StepAddr, StepId, StringId, StringsView,
+    Symbol, SymbolsView, Trampoline, TriviaEntry, TriviaView, TypeData, TypeDef, TypeId, TypeKind,
+    TypeMember, TypeName, TypesView, VERSION, align_to_section, cols, dump, format_effect,
+    nav_symbol, select_match_opcode, superscript, trace, truncate_text, width_for_count,
 };
 pub use dfa::deserialize_dfa;
 pub use predicate_op::PredicateOp;
diff --git a/crates/plotnik-cli/src/commands/exec.rs b/crates/plotnik-cli/src/commands/exec.rs
index eaf677d..10bcfc2 100644
--- a/crates/plotnik-cli/src/commands/exec.rs
+++ b/crates/plotnik-cli/src/commands/exec.rs
@@ -35,7 +35,9 @@ pub fn run(args: ExecArgs) {
         color: args.color,
     });
 
-    let vm = VM::builder(&source_code, &tree).trivia_types(trivia_types).build();
+    let vm = VM::builder(&source_code, &tree)
+        .trivia_types(trivia_types)
+        .build();
     let effects = match vm.execute(&module, 0, &entrypoint) {
         Ok(effects) => effects,
         Err(RuntimeError::NoMatch) => {
diff --git a/crates/plotnik-compiler/src/analyze/validation/predicates.rs b/crates/plotnik-compiler/src/analyze/validation/predicates.rs
index 3d2384a..232daa1 100644
--- a/crates/plotnik-compiler/src/analyze/validation/predicates.rs
+++ b/crates/plotnik-compiler/src/analyze/validation/predicates.rs
@@ -5,7 +5,7 @@
 //! - Lookahead/lookbehind (`(?=...)`, `(?!...)`, etc.)
 //! - Named captures (`(?P<name>...)`)
 
-use regex_syntax::ast::{self, visit, Ast, GroupKind, Visitor as RegexVisitor};
+use regex_syntax::ast::{self, Ast, GroupKind, Visitor as RegexVisitor, visit};
 use rowan::TextRange;
 
 use crate::SourceId;
@@ -13,12 +13,7 @@ use crate::analyze::visitor::{Visitor, walk_named_node};
 use crate::diagnostics::{DiagnosticKind, Diagnostics};
 use crate::parser::{NamedNode, Root};
 
-pub fn validate_predicates(
-    source_id: SourceId,
-    source: &str,
-    ast: &Root,
-    diag: &mut Diagnostics,
-) {
+pub fn validate_predicates(source_id: SourceId, source: &str, ast: &Root, diag: &mut Diagnostics) {
     let mut validator = PredicateValidator {
         diag,
         source_id,
@@ -69,13 +64,16 @@ impl PredicateValidator<'_, '_> {
                 let span = self.map_regex_span(e.span(), regex_range);
                 let report = match e.kind() {
                     ast::ErrorKind::UnsupportedBackreference => {
-                        self.diag.report(self.source_id, DiagnosticKind::RegexBackreference, span)
+                        self.diag
+                            .report(self.source_id, DiagnosticKind::RegexBackreference, span)
                     }
                     ast::ErrorKind::UnsupportedLookAround => {
                         // Skip the opening `(` - point at `?=` / `?!` / `?<=` / `?<!`
                         use rowan::TextSize;
-                        let adjusted = TextRange::new(span.start() + TextSize::from(1u32), span.end());
-                        self.diag.report(self.source_id, DiagnosticKind::RegexLookaround, adjusted)
+                        let adjusted =
+                            TextRange::new(span.start() + TextSize::from(1u32), span.end());
+                        self.diag
+                            .report(self.source_id, DiagnosticKind::RegexLookaround, adjusted)
                     }
                     _ => self
                         .diag
@@ -128,8 +126,16 @@ impl RegexVisitor for NamedCaptureDetector {
             && let GroupKind::CaptureName { name, .. } = &group.kind
         {
             // Span for `?P<name>` (skip opening paren, include closing `>`)
-            let start = ast::Position::new(group.span.start.offset + 1, group.span.start.line, group.span.start.column + 1);
-            let end = ast::Position::new(name.span.end.offset + 1, name.span.end.line, name.span.end.column + 1);
+            let start = ast::Position::new(
+                group.span.start.offset + 1,
+                group.span.start.line,
+                group.span.start.column + 1,
+            );
+            let end = ast::Position::new(
+                name.span.end.offset + 1,
+                name.span.end.line,
+                name.span.end.column + 1,
+            );
             self.named_captures.push(ast::Span::new(start, end));
         }
         Ok(())
diff --git a/crates/plotnik-compiler/src/bytecode/ir.rs b/crates/plotnik-compiler/src/bytecode/ir.rs
index aedae9c..8eed365 100644
--- a/crates/plotnik-compiler/src/bytecode/ir.rs
+++ b/crates/plotnik-compiler/src/bytecode/ir.rs
@@ -7,11 +7,11 @@
 use std::collections::BTreeMap;
 use std::num::NonZeroU16;
 
+use crate::analyze::type_check::TypeId;
 use plotnik_bytecode::{
     Call, EffectOp, EffectOpcode, Nav, Opcode, PredicateOp, Return, StepAddr, StepId, Trampoline,
     select_match_opcode,
 };
-use crate::analyze::type_check::TypeId;
 
 /// Node type constraint for Match instructions.
 ///
@@ -643,8 +643,9 @@ impl MatchIR {
 
                 let value_ref = match &pred.value {
                     PredicateValueIR::String(string_id) => string_id.get(),
-                    PredicateValueIR::Regex(string_id) => lookup_regex(*string_id)
-                        .expect("regex predicate must be interned"),
+                    PredicateValueIR::Regex(string_id) => {
+                        lookup_regex(*string_id).expect("regex predicate must be interned")
+                    }
                 };
                 bytes[offset..offset + 2].copy_from_slice(&value_ref.to_le_bytes());
                 offset += 2;
diff --git a/crates/plotnik-compiler/src/compile/capture.rs b/crates/plotnik-compiler/src/compile/capture.rs
index 8c399e1..1529619 100644
--- a/crates/plotnik-compiler/src/compile/capture.rs
+++ b/crates/plotnik-compiler/src/compile/capture.rs
@@ -7,8 +7,8 @@ use std::collections::HashSet;
 
 use crate::analyze::type_check::{TypeContext, TypeId, TypeShape};
 use crate::bytecode::EffectIR;
-use plotnik_bytecode::EffectOpcode;
 use crate::parser::ast::{self, Expr};
+use plotnik_bytecode::EffectOpcode;
 
 use super::Compiler;
 use super::navigation::{inner_creates_scope, is_star_or_plus_quantifier, is_truly_empty_scope};
@@ -143,12 +143,12 @@ impl Compiler<'_> {
             if !inner_creates_scope(&ei) {
                 return false;
             }
-            let Some(info) = self.type_ctx.get_term_info(&ei) else {
+            let Some(info) = self.ctx.type_ctx.get_term_info(&ei) else {
                 return false;
             };
             info.flow
                 .type_id()
-                .and_then(|id| self.type_ctx.get_type(id))
+                .and_then(|id| self.ctx.type_ctx.get_type(id))
                 .is_some_and(|shape| matches!(shape, TypeShape::Struct(_) | TypeShape::Enum(_)))
         });
 
@@ -195,7 +195,7 @@ impl Compiler<'_> {
         }
 
         // Check the actual inferred type, not syntax
-        let Some(info) = self.type_ctx.get_term_info(&inner) else {
+        let Some(info) = self.ctx.type_ctx.get_term_info(&inner) else {
             return true;
         };
 
@@ -204,7 +204,7 @@ impl Compiler<'_> {
         !info
             .flow
             .type_id()
-            .and_then(|id| self.type_ctx.get_type(id))
+            .and_then(|id| self.ctx.type_ctx.get_type(id))
             .is_some_and(|shape| matches!(shape, TypeShape::Struct(_) | TypeShape::Enum(_)))
     }
 
@@ -235,9 +235,9 @@ impl Compiler<'_> {
     /// In this case, we skip emitting Node/Text effects in captures.
     fn ref_returns_structured(&self, r: &ast::Ref) -> bool {
         r.name()
-            .and_then(|name| self.type_ctx.get_def_id(self.interner, name.text()))
-            .and_then(|def_id| self.type_ctx.get_def_type(def_id))
-            .and_then(|def_type| self.type_ctx.get_type(def_type))
+            .and_then(|name| self.ctx.type_ctx.get_def_id(self.ctx.interner, name.text()))
+            .and_then(|def_id| self.ctx.type_ctx.get_def_type(def_id))
+            .and_then(|def_type| self.ctx.type_ctx.get_type(def_type))
             .is_some_and(|shape| {
                 matches!(
                     shape,
diff --git a/crates/plotnik-compiler/src/compile/capture_tests.rs b/crates/plotnik-compiler/src/compile/capture_tests.rs
index b6e5051..595738d 100644
--- a/crates/plotnik-compiler/src/compile/capture_tests.rs
+++ b/crates/plotnik-compiler/src/compile/capture_tests.rs
@@ -1,6 +1,6 @@
 use super::capture::CaptureEffects;
-use plotnik_bytecode::EffectOpcode;
 use crate::bytecode::{EffectIR, MemberRef};
+use plotnik_bytecode::EffectOpcode;
 
 #[test]
 fn nest_scope_preserves_outer_and_nests_inner() {
diff --git a/crates/plotnik-compiler/src/compile/compile_tests.rs b/crates/plotnik-compiler/src/compile/compile_tests.rs
index 255127e..622f9b7 100644
--- a/crates/plotnik-compiler/src/compile/compile_tests.rs
+++ b/crates/plotnik-compiler/src/compile/compile_tests.rs
@@ -1,8 +1,23 @@
 //! Integration tests for the compilation pipeline.
 
+use std::cell::RefCell;
+
 use super::*;
-use crate::emit::StringTableBuilder;
-use crate::query::QueryBuilder;
+use crate::{emit::StringTableBuilder, query::QueryBuilder};
+
+/// Helper to compile a query with default context.
+fn compile_query(query: &crate::query::QueryAnalyzed) -> CompileResult {
+    let strings = RefCell::new(StringTableBuilder::new());
+    let ctx = CompileCtx {
+        interner: query.interner(),
+        type_ctx: query.type_context(),
+        symbol_table: &query.symbol_table,
+        strings: &strings,
+        node_types: None,
+        node_fields: None,
+    };
+    Compiler::compile(&ctx).unwrap()
+}
 
 #[test]
 fn compile_simple_named_node() {
@@ -11,16 +26,7 @@ fn compile_simple_named_node() {
         .unwrap()
         .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     // Should have at least one instruction
     assert!(!result.instructions.is_empty());
@@ -35,16 +41,7 @@ fn compile_alternation() {
         .unwrap()
         .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     assert!(!result.instructions.is_empty());
 }
@@ -56,16 +53,7 @@ fn compile_sequence() {
         .unwrap()
         .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     assert!(!result.instructions.is_empty());
 }
@@ -77,16 +65,7 @@ fn compile_quantified() {
         .unwrap()
         .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     assert!(!result.instructions.is_empty());
 }
@@ -98,16 +77,7 @@ fn compile_capture() {
         .unwrap()
         .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     assert!(!result.instructions.is_empty());
 }
@@ -119,16 +89,7 @@ fn compile_nested() {
         .unwrap()
         .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     assert!(!result.instructions.is_empty());
 }
@@ -148,16 +109,7 @@ fn compile_large_tagged_alternation() {
         .unwrap()
         .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     assert!(!result.instructions.is_empty());
 }
@@ -174,16 +126,7 @@ fn compile_unlabeled_alternation_5_branches_with_captures() {
     .unwrap()
     .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     assert!(!result.instructions.is_empty());
 
@@ -213,16 +156,7 @@ fn compile_unlabeled_alternation_8_branches_with_captures() {
     .unwrap()
     .analyze();
 
-    let mut strings = StringTableBuilder::new();
-    let result = Compiler::compile(
-        query.interner(),
-        query.type_context(),
-        &query.symbol_table,
-        &mut strings,
-        None,
-        None,
-    )
-    .unwrap();
+    let result = compile_query(&query);
 
     assert!(!result.instructions.is_empty());
 }
diff --git a/crates/plotnik-compiler/src/compile/compiler.rs b/crates/plotnik-compiler/src/compile/compiler.rs
index 93a465a..6f0e95e 100644
--- a/crates/plotnik-compiler/src/compile/compiler.rs
+++ b/crates/plotnik-compiler/src/compile/compiler.rs
@@ -1,27 +1,40 @@
 //! Core compiler state and entry points.
 
+use std::cell::RefCell;
+
 use indexmap::IndexMap;
 use plotnik_core::{Interner, NodeFieldId, NodeTypeId, Symbol};
 
 use crate::analyze::symbol_table::SymbolTable;
 use crate::analyze::type_check::{DefId, TypeContext};
-use plotnik_bytecode::Nav;
 use crate::bytecode::{InstructionIR, Label, ReturnIR, TrampolineIR};
 use crate::emit::StringTableBuilder;
 use crate::parser::Expr;
+use plotnik_bytecode::Nav;
 
 use super::capture::CaptureEffects;
+use super::dce::remove_unreachable;
+use super::epsilon_elim::eliminate_epsilons;
 use super::error::{CompileError, CompileResult};
 use super::scope::StructScope;
+use super::verify::debug_verify_ir_fingerprint;
+
+/// Compilation context bundling all shared compilation state.
+///
+/// Uses `RefCell` for `strings` to allow interior mutability while
+/// sharing the context across compilation phases.
+pub struct CompileCtx<'a> {
+    pub interner: &'a Interner,
+    pub type_ctx: &'a TypeContext,
+    pub symbol_table: &'a SymbolTable,
+    pub strings: &'a RefCell<StringTableBuilder>,
+    pub node_types: Option<&'a IndexMap<Symbol, NodeTypeId>>,
+    pub node_fields: Option<&'a IndexMap<Symbol, NodeFieldId>>,
+}
 
 /// Compiler state for Thompson construction.
 pub struct Compiler<'a> {
-    pub(super) interner: &'a Interner,
-    pub(super) type_ctx: &'a TypeContext,
-    pub(crate) 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) ctx: &'a CompileCtx<'a>,
     pub(super) instructions: Vec<InstructionIR>,
     pub(crate) next_label_id: u32,
     pub(super) def_entries: IndexMap<DefId, Label>,
@@ -30,111 +43,50 @@ pub struct Compiler<'a> {
     pub(super) scope_stack: Vec<StructScope>,
 }
 
-/// Builder for `Compiler`.
-pub struct CompilerBuilder<'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>>,
-}
-
-impl<'a> CompilerBuilder<'a> {
-    /// Create a new builder with required parameters.
-    pub fn new(
-        interner: &'a Interner,
-        type_ctx: &'a TypeContext,
-        symbol_table: &'a SymbolTable,
-        strings: &'a mut StringTableBuilder,
-    ) -> Self {
+impl<'a> Compiler<'a> {
+    /// Create a new compiler with the given context.
+    pub fn new(ctx: &'a CompileCtx<'a>) -> Self {
         Self {
-            interner,
-            type_ctx,
-            symbol_table,
-            strings,
-            node_type_ids: None,
-            node_field_ids: None,
-        }
-    }
-
-    /// Set node type and field IDs for linked compilation.
-    pub fn linked(
-        mut self,
-        node_type_ids: &'a IndexMap<Symbol, NodeTypeId>,
-        node_field_ids: &'a IndexMap<Symbol, NodeFieldId>,
-    ) -> Self {
-        self.node_type_ids = Some(node_type_ids);
-        self.node_field_ids = Some(node_field_ids);
-        self
-    }
-
-    /// Build the Compiler.
-    pub fn build(self) -> Compiler<'a> {
-        Compiler {
-            interner: self.interner,
-            type_ctx: self.type_ctx,
-            symbol_table: self.symbol_table,
-            strings: self.strings,
-            node_type_ids: self.node_type_ids,
-            node_field_ids: self.node_field_ids,
+            ctx,
             instructions: Vec::new(),
             next_label_id: 0,
             def_entries: IndexMap::new(),
             scope_stack: Vec::new(),
         }
     }
-}
-
-impl<'a> Compiler<'a> {
-    /// Create a builder for Compiler.
-    pub fn builder(
-        interner: &'a Interner,
-        type_ctx: &'a TypeContext,
-        symbol_table: &'a SymbolTable,
-        strings: &'a mut StringTableBuilder,
-    ) -> CompilerBuilder<'a> {
-        CompilerBuilder::new(interner, type_ctx, symbol_table, strings)
-    }
 
     /// 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 =
-            if let (Some(type_ids), Some(field_ids)) = (node_type_ids, node_field_ids) {
-                Compiler::builder(interner, type_ctx, symbol_table, strings)
-                    .linked(type_ids, field_ids)
-                    .build()
-            } else {
-                Compiler::builder(interner, type_ctx, symbol_table, strings).build()
-            };
+    pub fn compile(ctx: &'a CompileCtx<'a>) -> Result<CompileResult, CompileError> {
+        let mut compiler = Compiler::new(ctx);
 
         // Emit universal preamble first: Obj -> Trampoline -> EndObj -> Return
         // This wraps any entrypoint to create the top-level scope.
         let preamble_entry = compiler.emit_preamble();
 
         // Pre-allocate entry labels for all definitions
-        for (def_id, _) in type_ctx.iter_def_types() {
+        for (def_id, _) in ctx.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() {
+        for (def_id, _) in ctx.type_ctx.iter_def_types() {
             compiler.compile_def(def_id)?;
         }
 
-        Ok(CompileResult {
+        let mut result = CompileResult {
             instructions: compiler.instructions,
             def_entries: compiler.def_entries,
             preamble_entry,
-        })
+        };
+
+        // Eliminate epsilon transitions (with semantic verification in debug builds)
+        eliminate_epsilons(&mut result, ctx);
+
+        // Remove unreachable instructions (bypassed epsilons, etc.)
+        remove_unreachable(&mut result);
+
+        Ok(result)
     }
 
     /// Emit the universal preamble: Obj -> Trampoline -> EndObj -> Return
@@ -165,10 +117,10 @@ impl<'a> Compiler<'a> {
 
     /// 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 name_sym = self.ctx.type_ctx.def_name_sym(def_id);
+        let name = self.ctx.interner.resolve(name_sym);
 
-        let Some(body) = self.symbol_table.get(name) else {
+        let Some(body) = self.ctx.symbol_table.get(name) else {
             return Err(CompileError::DefinitionNotFound(name.to_string()));
         };
 
@@ -189,7 +141,7 @@ impl<'a> Compiler<'a> {
         // Definitions are compiled in normalized form: body -> Return
         // No Obj/EndObj wrapper - that's the caller's responsibility (call-site scoping).
         // We still use with_scope for member index lookup during compilation.
-        let body_entry = if let Some(type_id) = self.type_ctx.get_def_type(def_id) {
+        let body_entry = if let Some(type_id) = self.ctx.type_ctx.get_def_type(def_id) {
             self.with_scope(type_id, |this| {
                 this.compile_expr_with_nav(body, return_label, body_nav)
             })
@@ -202,6 +154,15 @@ impl<'a> Compiler<'a> {
             self.emit_epsilon(entry_label, vec![body_entry]);
         }
 
+        // Debug-only: verify IR semantic fingerprint
+        debug_verify_ir_fingerprint(
+            &self.instructions,
+            entry_label,
+            &self.def_entries,
+            name,
+            self.ctx,
+        );
+
         Ok(())
     }
 
diff --git a/crates/plotnik-compiler/src/compile/dce.rs b/crates/plotnik-compiler/src/compile/dce.rs
new file mode 100644
index 0000000..2a4307b
--- /dev/null
+++ b/crates/plotnik-compiler/src/compile/dce.rs
@@ -0,0 +1,135 @@
+//! Dead code elimination pass.
+//!
+//! Removes unreachable instructions after epsilon elimination.
+//! Instructions become unreachable when epsilon transitions are
+//! bypassed and no other path leads to them.
+
+use std::collections::HashSet;
+
+use crate::bytecode::Label;
+
+use super::error::CompileResult;
+
+/// Remove instructions not reachable from any entry point.
+///
+/// This pass runs after epsilon elimination to clean up instructions
+/// that were bypassed during optimization.
+pub fn remove_unreachable(result: &mut CompileResult) {
+    let reachable = compute_reachable(result);
+    result
+        .instructions
+        .retain(|instr| reachable.contains(&instr.label()));
+}
+
+/// Compute all labels reachable from entry points via BFS.
+fn compute_reachable(result: &CompileResult) -> HashSet<Label> {
+    // Build successor map
+    let successors: std::collections::BTreeMap<Label, Vec<Label>> = result
+        .instructions
+        .iter()
+        .map(|instr| (instr.label(), instr.successors()))
+        .collect();
+
+    // BFS from all entry points
+    let mut reachable = HashSet::new();
+    let mut queue: Vec<Label> = vec![result.preamble_entry];
+    queue.extend(result.def_entries.values().copied());
+
+    while let Some(label) = queue.pop() {
+        if !reachable.insert(label) {
+            continue;
+        }
+        if let Some(succs) = successors.get(&label) {
+            queue.extend(succs.iter().copied());
+        }
+    }
+
+    reachable
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::analyze::type_check::DefId;
+    use crate::bytecode::MatchIR;
+    use indexmap::IndexMap;
+    use plotnik_bytecode::Nav;
+
+    #[test]
+    fn removes_unreachable_instructions() {
+        // A -> B (reachable), C (unreachable)
+        let instructions = vec![
+            MatchIR::at(Label(0)).nav(Nav::Down).next(Label(1)).into(),
+            MatchIR::terminal(Label(1)).nav(Nav::Down).into(),
+            MatchIR::terminal(Label(2)).nav(Nav::Down).into(), // unreachable
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: {
+                let mut m = IndexMap::new();
+                m.insert(DefId::from_raw(0), Label(0));
+                m
+            },
+            preamble_entry: Label(0),
+        };
+
+        remove_unreachable(&mut result);
+
+        assert_eq!(result.instructions.len(), 2);
+        assert!(result.instructions.iter().any(|i| i.label() == Label(0)));
+        assert!(result.instructions.iter().any(|i| i.label() == Label(1)));
+        assert!(!result.instructions.iter().any(|i| i.label() == Label(2)));
+    }
+
+    #[test]
+    fn keeps_all_when_all_reachable() {
+        // A -> B -> C (all reachable)
+        let instructions = vec![
+            MatchIR::at(Label(0)).nav(Nav::Down).next(Label(1)).into(),
+            MatchIR::at(Label(1)).nav(Nav::Down).next(Label(2)).into(),
+            MatchIR::terminal(Label(2)).nav(Nav::Down).into(),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: {
+                let mut m = IndexMap::new();
+                m.insert(DefId::from_raw(0), Label(0));
+                m
+            },
+            preamble_entry: Label(0),
+        };
+
+        remove_unreachable(&mut result);
+
+        assert_eq!(result.instructions.len(), 3);
+    }
+
+    #[test]
+    fn handles_branching() {
+        // A -> [B, C] (all reachable via branch)
+        let instructions = vec![
+            MatchIR::at(Label(0))
+                .nav(Nav::Down)
+                .next_many(vec![Label(1), Label(2)])
+                .into(),
+            MatchIR::terminal(Label(1)).nav(Nav::Down).into(),
+            MatchIR::terminal(Label(2)).nav(Nav::Down).into(),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: {
+                let mut m = IndexMap::new();
+                m.insert(DefId::from_raw(0), Label(0));
+                m
+            },
+            preamble_entry: Label(0),
+        };
+
+        remove_unreachable(&mut result);
+
+        assert_eq!(result.instructions.len(), 3);
+    }
+}
diff --git a/crates/plotnik-compiler/src/compile/epsilon_elim.rs b/crates/plotnik-compiler/src/compile/epsilon_elim.rs
new file mode 100644
index 0000000..44647d7
--- /dev/null
+++ b/crates/plotnik-compiler/src/compile/epsilon_elim.rs
@@ -0,0 +1,786 @@
+//! Epsilon elimination pass.
+//!
+//! Eliminates epsilon transitions (pure control flow) from IR while preserving semantics.
+//! Uses a three-phase iterative approach:
+//!
+//! 1. **Forward migration**: Effectful epsilons push effects to exclusive successors
+//! 2. **Expand branching**: Effectless branching epsilons expanded into predecessors
+//! 3. **Laser vision**: Instructions look through epsilon chains, absorbing or bypassing
+//!
+//! Phases iterate until no changes occur.
+
+use std::collections::{HashMap, HashSet};
+
+use crate::bytecode::{EffectIR, InstructionIR, Label, MatchIR};
+use crate::compile::error::CompileResult;
+
+/// Build label → index map for quick instruction lookup.
+fn build_label_to_index(instructions: &[InstructionIR]) -> HashMap<Label, usize> {
+    instructions
+        .iter()
+        .enumerate()
+        .map(|(i, instr)| (instr.label(), i))
+        .collect()
+}
+
+/// Build predecessor map: label → labels that transition to it.
+fn build_predecessor_map(instructions: &[InstructionIR]) -> HashMap<Label, Vec<Label>> {
+    let mut preds: HashMap<Label, Vec<Label>> = HashMap::new();
+    for instr in instructions {
+        let from = instr.label();
+        for succ in instr.successors() {
+            preds.entry(succ).or_default().push(from);
+        }
+    }
+    preds
+}
+
+/// Get a Match instruction by label.
+fn get_match<'a>(
+    label: Label,
+    instructions: &'a [InstructionIR],
+    idx: &HashMap<Label, usize>,
+) -> Option<&'a MatchIR> {
+    match &instructions[*idx.get(&label)?] {
+        InstructionIR::Match(m) => Some(m),
+        _ => None,
+    }
+}
+
+/// Get a mutable Match instruction by label.
+fn get_match_mut<'a>(
+    label: Label,
+    instructions: &'a mut [InstructionIR],
+    idx: &HashMap<Label, usize>,
+) -> Option<&'a mut MatchIR> {
+    match &mut instructions[*idx.get(&label)?] {
+        InstructionIR::Match(m) => Some(m),
+        _ => None,
+    }
+}
+
+/// See through single-successor epsilon chains.
+///
+/// Returns `(target, accumulated_effects)` or `None` if blocked by:
+/// - Branching epsilon (multiple successors)
+/// - Cycle
+fn see_through(
+    start: Label,
+    instructions: &[InstructionIR],
+    idx: &HashMap<Label, usize>,
+) -> Option<(Label, Vec<EffectIR>)> {
+    let mut current = start;
+    let mut effects = Vec::new();
+    let mut visited = HashSet::new();
+
+    loop {
+        if !visited.insert(current) {
+            return None; // Cycle
+        }
+
+        let Some(m) = get_match(current, instructions, idx) else {
+            return Some((current, effects)); // Non-Match target (Call/Return/Trampoline)
+        };
+
+        if !m.is_epsilon() {
+            return Some((current, effects)); // Visible: non-epsilon Match
+        }
+
+        if m.successors.len() != 1 {
+            return Some((current, effects)); // Branching epsilon: visible but can't see through
+        }
+
+        // Single-succ epsilon: absorb effects, continue looking
+        effects.extend(m.pre_effects.iter().cloned());
+        effects.extend(m.post_effects.iter().cloned());
+        current = m.successors[0];
+    }
+}
+
+/// Phase A: Forward migration.
+///
+/// Effectful epsilons with exclusive edge to a non-epsilon successor
+/// push their effects forward, becoming effectless.
+fn forward_migrate(instructions: &mut [InstructionIR]) -> bool {
+    let mut changed = false;
+    let preds = build_predecessor_map(instructions);
+    let idx = build_label_to_index(instructions);
+
+    for i in 0..instructions.len() {
+        let eps = match &instructions[i] {
+            InstructionIR::Match(m) if m.is_epsilon() => m,
+            _ => continue,
+        };
+
+        // Skip effectless epsilons
+        if eps.pre_effects.is_empty() && eps.post_effects.is_empty() {
+            continue;
+        }
+
+        // Must have single successor
+        if eps.successors.len() != 1 {
+            continue;
+        }
+
+        let succ_label = eps.successors[0];
+
+        // Successor must be a non-epsilon Match
+        let Some(succ) = get_match(succ_label, instructions, &idx) else {
+            continue;
+        };
+        if succ.is_epsilon() {
+            continue;
+        }
+
+        // This epsilon must be successor's ONLY predecessor (exclusive edge)
+        let is_exclusive = preds
+            .get(&succ_label)
+            .is_some_and(|p| p.len() == 1 && p[0] == eps.label);
+        if !is_exclusive {
+            continue;
+        }
+
+        // Migrate: effects go to successor's pre_effects (in order: eps.pre, eps.post, succ.pre)
+        let eps_label = eps.label;
+        let eps_pre = eps.pre_effects.clone();
+        let eps_post = eps.post_effects.clone();
+
+        let succ = get_match_mut(succ_label, instructions, &idx).unwrap();
+        let mut new_pre = eps_pre;
+        new_pre.extend(eps_post);
+        new_pre.append(&mut succ.pre_effects);
+        succ.pre_effects = new_pre;
+
+        let eps = get_match_mut(eps_label, instructions, &idx).unwrap();
+        eps.pre_effects.clear();
+        eps.post_effects.clear();
+
+        changed = true;
+    }
+
+    changed
+}
+
+/// Phase B: Laser vision rewrites.
+///
+/// Each instruction looks through epsilon chains to find reachable targets:
+/// - Single-successor instructions can absorb effects
+/// - Multi-successor instructions follow effectless chains only
+fn laser_vision(result: &mut CompileResult) -> bool {
+    let mut changed = false;
+    let idx = build_label_to_index(&result.instructions);
+
+    // Entry points: resolve through effectless chains
+    // Track old->new mappings to update Call targets
+    let mut entry_remaps: HashMap<Label, Label> = HashMap::new();
+    for entry in result.def_entries.values_mut() {
+        if let Some((target, effects)) = see_through(*entry, &result.instructions, &idx)
+            && effects.is_empty()
+            && target != *entry
+        {
+            entry_remaps.insert(*entry, target);
+            *entry = target;
+            changed = true;
+        }
+    }
+
+    // Update Call targets to match updated def_entries
+    for instr in &mut result.instructions {
+        if let InstructionIR::Call(c) = instr
+            && let Some(&new) = entry_remaps.get(&c.target)
+        {
+            c.target = new;
+        }
+    }
+
+    // Preamble entry
+    if let Some((target, effects)) = see_through(result.preamble_entry, &result.instructions, &idx)
+        && effects.is_empty()
+        && target != result.preamble_entry
+    {
+        result.preamble_entry = target;
+        changed = true;
+    }
+
+    // Non-epsilon Match instructions: resolve successors
+    for i in 0..result.instructions.len() {
+        let m = match &result.instructions[i] {
+            InstructionIR::Match(m) if !m.is_epsilon() => m,
+            _ => continue,
+        };
+
+        let single = m.successors.len() == 1;
+        let mut succs = m.successors.clone();
+        let mut post = m.post_effects.clone();
+        let mut modified = false;
+
+        for (j, &succ) in m.successors.iter().enumerate() {
+            let Some((target, effects)) = see_through(succ, &result.instructions, &idx) else {
+                continue;
+            };
+
+            if target == succ {
+                continue; // Nothing to see through
+            }
+
+            // Effects require single successor (can't execute for all paths)
+            if !effects.is_empty() && !single {
+                continue;
+            }
+
+            succs[j] = target;
+            post.extend(effects);
+            modified = true;
+        }
+
+        if modified {
+            let m = match &mut result.instructions[i] {
+                InstructionIR::Match(m) => m,
+                _ => unreachable!(),
+            };
+            m.successors = succs;
+            m.post_effects = post;
+            changed = true;
+        }
+    }
+
+    // Call/Trampoline: resolve next (effectless only)
+    for i in 0..result.instructions.len() {
+        let next_label = match &result.instructions[i] {
+            InstructionIR::Call(c) => Some(c.next),
+            InstructionIR::Trampoline(t) => Some(t.next),
+            _ => None,
+        };
+
+        let Some(next) = next_label else { continue };
+        let Some((target, effects)) = see_through(next, &result.instructions, &idx) else {
+            continue;
+        };
+
+        if effects.is_empty() && target != next {
+            match &mut result.instructions[i] {
+                InstructionIR::Call(c) => c.next = target,
+                InstructionIR::Trampoline(t) => t.next = target,
+                _ => {}
+            }
+            changed = true;
+        }
+    }
+
+    changed
+}
+
+/// Phase C: Expand branching epsilons.
+///
+/// Effectless branching epsilons are expanded by replacing the epsilon
+/// reference in each predecessor with the epsilon's successors.
+///
+/// Before:  a → [ε, x], ε → [d, e, f]
+/// After:   a → [d, e, f, x]
+///
+/// The epsilon becomes unreachable and is eliminated during layout.
+fn expand_branching_epsilons(result: &mut CompileResult) -> bool {
+    let idx = build_label_to_index(&result.instructions);
+    let preds = build_predecessor_map(&result.instructions);
+    let mut changed = false;
+
+    for i in 0..result.instructions.len() {
+        let m = match &result.instructions[i] {
+            InstructionIR::Match(m) => m,
+            _ => continue,
+        };
+
+        // Must be effectless epsilon with multiple successors
+        if !m.is_epsilon() {
+            continue;
+        }
+        if !m.pre_effects.is_empty() || !m.post_effects.is_empty() {
+            continue;
+        }
+        if m.successors.len() <= 1 {
+            continue; // Single-succ handled by laser_vision
+        }
+
+        let eps_label = m.label;
+        let eps_succs = m.successors.clone();
+
+        // Expand into each predecessor
+        if let Some(pred_labels) = preds.get(&eps_label) {
+            for &pred_label in pred_labels {
+                let pred_idx = idx[&pred_label];
+                if let InstructionIR::Match(pred) = &mut result.instructions[pred_idx]
+                    && let Some(pos) = pred.successors.iter().position(|&l| l == eps_label)
+                {
+                    pred.successors
+                        .splice(pos..pos + 1, eps_succs.iter().cloned());
+                    changed = true;
+                }
+                // Call/Trampoline have single `next` - can't expand branching into them
+            }
+        }
+    }
+
+    changed
+}
+
+/// Eliminate epsilon transitions from compiled IR.
+///
+/// In debug builds, verifies semantic fingerprints are preserved.
+#[allow(unused_variables)]
+pub fn eliminate_epsilons(result: &mut CompileResult, ctx: &super::compiler::CompileCtx) {
+    #[cfg(debug_assertions)]
+    let before: Vec<_> = {
+        use super::verify::fingerprint_from_ir;
+        result
+            .def_entries
+            .iter()
+            .map(|(def_id, &entry)| {
+                let fp = fingerprint_from_ir(&result.instructions, entry, &result.def_entries, ctx);
+                (*def_id, fp)
+            })
+            .collect()
+    };
+
+    // Iterate phases until fixed point
+    loop {
+        let a = forward_migrate(&mut result.instructions);
+        let b = expand_branching_epsilons(result);
+        let c = laser_vision(result);
+        if !a && !b && !c {
+            break;
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    {
+        use super::verify::fingerprint_from_ir;
+        for (def_id, before_fp) in before {
+            let entry = result.def_entries[&def_id];
+            let after_fp =
+                fingerprint_from_ir(&result.instructions, entry, &result.def_entries, ctx);
+
+            if before_fp != after_fp {
+                eprintln!("=== Fingerprint mismatch for def {:?} ===", def_id);
+                eprintln!("Before ({} paths):", before_fp.len());
+                for (i, path) in before_fp.iter().enumerate() {
+                    eprintln!("  {}: {:?}", i, path);
+                }
+                eprintln!("After ({} paths):", after_fp.len());
+                for (i, path) in after_fp.iter().enumerate() {
+                    eprintln!("  {}: {:?}", i, path);
+                }
+                panic!("epsilon elimination changed semantics for def {:?}", def_id);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::bytecode::EffectIR;
+    use plotnik_bytecode::Nav;
+
+    fn make_epsilon(label: u32, succs: Vec<u32>) -> InstructionIR {
+        InstructionIR::Match(
+            MatchIR::at(Label(label))
+                .nav(Nav::Epsilon)
+                .next_many(succs.into_iter().map(Label).collect()),
+        )
+    }
+
+    fn make_match(label: u32, nav: Nav, succs: Vec<u32>) -> InstructionIR {
+        InstructionIR::Match(
+            MatchIR::at(Label(label))
+                .nav(nav)
+                .next_many(succs.into_iter().map(Label).collect()),
+        )
+    }
+
+    fn make_epsilon_with_pre(label: u32, succs: Vec<u32>) -> InstructionIR {
+        InstructionIR::Match(
+            MatchIR::at(Label(label))
+                .nav(Nav::Epsilon)
+                .pre_effect(EffectIR::start_obj())
+                .next_many(succs.into_iter().map(Label).collect()),
+        )
+    }
+
+    fn make_epsilon_with_post(label: u32, succs: Vec<u32>) -> InstructionIR {
+        InstructionIR::Match(
+            MatchIR::at(Label(label))
+                .nav(Nav::Epsilon)
+                .post_effect(EffectIR::end_obj())
+                .next_many(succs.into_iter().map(Label).collect()),
+        )
+    }
+
+    #[test]
+    fn see_through_effectless_chain() {
+        // 0 (ε) → 1 (ε) → 2 (match)
+        let instructions = vec![
+            make_epsilon(0, vec![1]),
+            make_epsilon(1, vec![2]),
+            make_match(2, Nav::Down, vec![]),
+        ];
+        let idx = build_label_to_index(&instructions);
+
+        let (target, effects) = see_through(Label(0), &instructions, &idx).unwrap();
+        assert_eq!(target, Label(2));
+        assert!(effects.is_empty());
+    }
+
+    #[test]
+    fn see_through_with_effects() {
+        // 0 (ε+Obj) → 1 (ε+EndObj) → 2 (match)
+        let instructions = vec![
+            make_epsilon_with_pre(0, vec![1]),
+            make_epsilon_with_post(1, vec![2]),
+            make_match(2, Nav::Down, vec![]),
+        ];
+        let idx = build_label_to_index(&instructions);
+
+        let (target, effects) = see_through(Label(0), &instructions, &idx).unwrap();
+        assert_eq!(target, Label(2));
+        assert_eq!(effects.len(), 2); // Obj from 0, EndObj from 1
+    }
+
+    #[test]
+    fn see_through_blocked_by_branch() {
+        // 0 (ε) → 1 (ε, branching) → [2, 3]
+        let instructions = vec![
+            make_epsilon(0, vec![1]),
+            make_epsilon(1, vec![2, 3]),
+            make_match(2, Nav::Down, vec![]),
+            make_match(3, Nav::Down, vec![]),
+        ];
+        let idx = build_label_to_index(&instructions);
+
+        // Can see through 0 to 1, but 1 is branching
+        let (target, effects) = see_through(Label(0), &instructions, &idx).unwrap();
+        assert_eq!(target, Label(1)); // Stops at branching epsilon
+        assert!(effects.is_empty());
+
+        // Starting from branching epsilon returns itself
+        let (target, effects) = see_through(Label(1), &instructions, &idx).unwrap();
+        assert_eq!(target, Label(1));
+        assert!(effects.is_empty());
+    }
+
+    #[test]
+    fn forward_migrate_to_exclusive_successor() {
+        // 0 (ε+Obj) → 1 (match), only 0 points to 1
+        let mut instructions = vec![
+            make_epsilon_with_pre(0, vec![1]),
+            make_match(1, Nav::Down, vec![]),
+        ];
+
+        forward_migrate(&mut instructions);
+
+        // Effects moved to 1.pre
+        let eps = match &instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert!(eps.pre_effects.is_empty());
+
+        let m1 = match &instructions[1] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m1.pre_effects.len(), 1);
+    }
+
+    #[test]
+    fn forward_migrate_blocked_by_multi_pred() {
+        // 0, 2 both point to 1 (match)
+        // ε can't forward-migrate because 1 has multiple preds
+        let mut instructions = vec![
+            make_epsilon_with_pre(0, vec![1]),
+            make_match(1, Nav::Down, vec![]),
+            make_match(2, Nav::Down, vec![1]),
+        ];
+
+        forward_migrate(&mut instructions);
+
+        // Effects NOT moved (1 has multiple predecessors)
+        let eps = match &instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(eps.pre_effects.len(), 1); // Still has effect
+    }
+
+    #[test]
+    fn laser_vision_single_succ_absorbs_effects() {
+        // 0 (match, single succ) → 1 (ε+Obj) → 2 (match)
+        let instructions = vec![
+            make_match(0, Nav::Down, vec![1]),
+            make_epsilon_with_pre(1, vec![2]),
+            make_match(2, Nav::Next, vec![]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: indexmap::IndexMap::new(),
+            preamble_entry: Label(0),
+        };
+
+        laser_vision(&mut result);
+
+        // 0 absorbed effects and now points to 2
+        let m0 = match &result.instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m0.successors, vec![Label(2)]);
+        assert_eq!(m0.post_effects.len(), 1);
+    }
+
+    #[test]
+    fn laser_vision_multi_succ_effectless_only() {
+        // 0 (match) → [1 (ε), 3]
+        // 1 (ε+Obj) → 2
+        let instructions = vec![
+            make_match(0, Nav::Down, vec![1, 3]),
+            make_epsilon_with_pre(1, vec![2]),
+            make_match(2, Nav::Next, vec![]),
+            make_match(3, Nav::Next, vec![]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: indexmap::IndexMap::new(),
+            preamble_entry: Label(0),
+        };
+
+        laser_vision(&mut result);
+
+        // 0 can't absorb effects (multi-succ), so 1 stays
+        let m0 = match &result.instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m0.successors, vec![Label(1), Label(3)]);
+        assert!(m0.post_effects.is_empty());
+    }
+
+    #[test]
+    fn combined_forward_then_laser() {
+        // The tricky case:
+        // 0 (match) → [1 (ε+Obj), 3]
+        // 1 → 2 (match), only 1 points to 2
+        //
+        // Phase A: 1 forward-migrates Obj to 2.pre, 1 becomes effectless
+        // Phase B: 0 sees through 1 (now effectless) to 2
+        let instructions = vec![
+            make_match(0, Nav::Down, vec![1, 3]),
+            make_epsilon_with_pre(1, vec![2]),
+            make_match(2, Nav::Next, vec![]),
+            make_match(3, Nav::Next, vec![]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: indexmap::IndexMap::new(),
+            preamble_entry: Label(0),
+        };
+
+        // Phase A
+        forward_migrate(&mut result.instructions);
+
+        // 1 should now be effectless, 2 has the effect
+        let eps = match &result.instructions[1] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert!(eps.pre_effects.is_empty());
+
+        let m2 = match &result.instructions[2] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m2.pre_effects.len(), 1);
+
+        // Phase B
+        laser_vision(&mut result);
+
+        // 0 should now point directly to 2
+        let m0 = match &result.instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m0.successors, vec![Label(2), Label(3)]);
+    }
+
+    #[test]
+    fn entry_point_resolution() {
+        // Entry at 0 (ε) → 1 (ε) → 2 (match)
+        let instructions = vec![
+            make_epsilon(0, vec![1]),
+            make_epsilon(1, vec![2]),
+            make_match(2, Nav::Down, vec![]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: {
+                let mut m = indexmap::IndexMap::new();
+                m.insert(crate::analyze::type_check::DefId::from_raw(0), Label(0));
+                m
+            },
+            preamble_entry: Label(0),
+        };
+
+        laser_vision(&mut result);
+
+        assert_eq!(
+            result.def_entries[&crate::analyze::type_check::DefId::from_raw(0)],
+            Label(2)
+        );
+    }
+
+    #[test]
+    fn branching_epsilon_preserved_by_laser_vision() {
+        // 0 (match) → 1 (ε, branching) → [2, 3]
+        let instructions = vec![
+            make_match(0, Nav::Down, vec![1]),
+            make_epsilon(1, vec![2, 3]),
+            make_match(2, Nav::Next, vec![]),
+            make_match(3, Nav::Next, vec![]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: indexmap::IndexMap::new(),
+            preamble_entry: Label(0),
+        };
+
+        // laser_vision alone can't see through branching epsilon
+        laser_vision(&mut result);
+
+        let m0 = match &result.instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m0.successors, vec![Label(1)]);
+    }
+
+    #[test]
+    fn expand_branching_epsilon() {
+        // 0 (match) → 1 (ε, branching) → [2, 3]
+        // After expansion: 0 → [2, 3]
+        let instructions = vec![
+            make_match(0, Nav::Down, vec![1]),
+            make_epsilon(1, vec![2, 3]),
+            make_match(2, Nav::Next, vec![]),
+            make_match(3, Nav::Next, vec![]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: indexmap::IndexMap::new(),
+            preamble_entry: Label(0),
+        };
+
+        expand_branching_epsilons(&mut result);
+
+        // 0 now points directly to [2, 3]
+        let m0 = match &result.instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m0.successors, vec![Label(2), Label(3)]);
+    }
+
+    #[test]
+    fn expand_branching_multiple_predecessors() {
+        // Both 0 and 4 point to branching epsilon 1
+        // 0 → 1 (ε) → [2, 3]
+        // 4 → 1
+        // After: 0 → [2, 3], 4 → [2, 3]
+        let instructions = vec![
+            make_match(0, Nav::Down, vec![1]),
+            make_epsilon(1, vec![2, 3]),
+            make_match(2, Nav::Next, vec![]),
+            make_match(3, Nav::Next, vec![]),
+            make_match(4, Nav::Down, vec![1]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: indexmap::IndexMap::new(),
+            preamble_entry: Label(0),
+        };
+
+        expand_branching_epsilons(&mut result);
+
+        let m0 = match &result.instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m0.successors, vec![Label(2), Label(3)]);
+
+        let m4 = match &result.instructions[4] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m4.successors, vec![Label(2), Label(3)]);
+    }
+
+    #[test]
+    fn expand_branching_preserves_other_successors() {
+        // 0 → [1 (ε), 4]
+        // 1 → [2, 3]
+        // After: 0 → [2, 3, 4]
+        let instructions = vec![
+            make_match(0, Nav::Down, vec![1, 4]),
+            make_epsilon(1, vec![2, 3]),
+            make_match(2, Nav::Next, vec![]),
+            make_match(3, Nav::Next, vec![]),
+            make_match(4, Nav::Next, vec![]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: indexmap::IndexMap::new(),
+            preamble_entry: Label(0),
+        };
+
+        expand_branching_epsilons(&mut result);
+
+        let m0 = match &result.instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m0.successors, vec![Label(2), Label(3), Label(4)]);
+    }
+
+    #[test]
+    fn expand_blocked_by_effects() {
+        // 0 → 1 (ε+Obj, branching) → [2, 3]
+        // Effectful branching epsilon cannot be expanded
+        let instructions = vec![
+            make_match(0, Nav::Down, vec![1]),
+            make_epsilon_with_pre(1, vec![2, 3]),
+            make_match(2, Nav::Next, vec![]),
+            make_match(3, Nav::Next, vec![]),
+        ];
+
+        let mut result = CompileResult {
+            instructions,
+            def_entries: indexmap::IndexMap::new(),
+            preamble_entry: Label(0),
+        };
+
+        let changed = expand_branching_epsilons(&mut result);
+        assert!(!changed);
+
+        // 0 still points to 1
+        let m0 = match &result.instructions[0] {
+            InstructionIR::Match(m) => m,
+            _ => panic!(),
+        };
+        assert_eq!(m0.successors, vec![Label(1)]);
+    }
+}
diff --git a/crates/plotnik-compiler/src/compile/expressions.rs b/crates/plotnik-compiler/src/compile/expressions.rs
index 92fc0d0..1dc74c3 100644
--- a/crates/plotnik-compiler/src/compile/expressions.rs
+++ b/crates/plotnik-compiler/src/compile/expressions.rs
@@ -10,9 +10,9 @@
 use std::num::NonZeroU16;
 
 use crate::analyze::type_check::TypeShape;
-use plotnik_bytecode::Nav;
 use crate::bytecode::{EffectIR, InstructionIR, Label, MatchIR, NodeTypeIR, PredicateIR};
 use crate::parser::ast::{self, Expr};
+use plotnik_bytecode::Nav;
 
 use super::Compiler;
 use super::capture::CaptureEffects;
@@ -268,7 +268,7 @@ impl Compiler<'_> {
         };
         let name = name_token.text();
 
-        let Some(def_id) = self.type_ctx.get_def_id(self.interner, name) else {
+        let Some(def_id) = self.ctx.type_ctx.get_def_id(self.ctx.interner, name) else {
             return exit;
         };
 
@@ -277,9 +277,9 @@ impl Compiler<'_> {
         };
 
         // Check if the called definition returns a struct (needs scope isolation when captured)
-        let def_type_id = self.type_ctx.get_def_type(def_id);
+        let def_type_id = self.ctx.type_ctx.get_def_type(def_id);
         let ref_returns_struct = def_type_id
-            .and_then(|tid| self.type_ctx.get_type(tid))
+            .and_then(|tid| self.ctx.type_ctx.get_type(tid))
             .is_some_and(|shape| matches!(shape, TypeShape::Struct(_)));
 
         // Determine if this is a captured ref that needs scope isolation
@@ -411,7 +411,9 @@ impl Compiler<'_> {
         }
 
         let inner = cap.inner();
-        let inner_info = inner.as_ref().and_then(|i| self.type_ctx.get_term_info(i));
+        let inner_info = inner
+            .as_ref()
+            .and_then(|i| self.ctx.type_ctx.get_term_info(i));
         let inner_is_bubble = inner_info
             .as_ref()
             .is_some_and(|info| info.flow.is_bubble());
@@ -472,7 +474,7 @@ impl Compiler<'_> {
             && inner_info
                 .as_ref()
                 .and_then(|info| info.flow.type_id())
-                .and_then(|id| self.type_ctx.get_type(id))
+                .and_then(|id| self.ctx.type_ctx.get_type(id))
                 .is_some_and(|shape| matches!(shape, TypeShape::Enum(_)));
 
         if inner_is_scope_creating_scalar {
@@ -541,10 +543,10 @@ impl Compiler<'_> {
     ///
     /// Returns `NodeTypeIR::Anonymous` with the type ID.
     pub(super) fn resolve_anonymous_node_type(&mut self, text: &str) -> NodeTypeIR {
-        if let Some(ids) = self.node_type_ids {
+        if let Some(ids) = self.ctx.node_types {
             // Linked mode: resolve to NodeTypeId from grammar
             for (&sym, &id) in ids {
-                if self.interner.resolve(sym) == text {
+                if self.ctx.interner.resolve(sym) == text {
                     return NodeTypeIR::Anonymous(NonZeroU16::new(id.get()));
                 }
             }
@@ -552,7 +554,7 @@ impl Compiler<'_> {
             NodeTypeIR::Anonymous(None)
         } else {
             // Unlinked mode: store StringId referencing the literal text
-            let string_id = self.strings.intern_str(text);
+            let string_id = self.ctx.strings.borrow_mut().intern_str(text);
             NodeTypeIR::Anonymous(Some(string_id.0))
         }
     }
@@ -574,10 +576,10 @@ impl Compiler<'_> {
         };
         let type_name = type_token.text();
 
-        if let Some(ids) = self.node_type_ids {
+        if let Some(ids) = self.ctx.node_types {
             // Linked mode: resolve to NodeTypeId from grammar
             for (&sym, &id) in ids {
-                if self.interner.resolve(sym) == type_name {
+                if self.ctx.interner.resolve(sym) == type_name {
                     return NodeTypeIR::Named(NonZeroU16::new(id.get()));
                 }
             }
@@ -585,7 +587,7 @@ impl Compiler<'_> {
             NodeTypeIR::Named(None)
         } else {
             // Unlinked mode: store StringId referencing the type name
-            let string_id = self.strings.intern_str(type_name);
+            let string_id = self.ctx.strings.borrow_mut().intern_str(type_name);
             NodeTypeIR::Named(Some(string_id.0))
         }
     }
@@ -605,10 +607,10 @@ impl Compiler<'_> {
     /// 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 {
+        if let Some(ids) = self.ctx.node_fields {
             // Linked mode: resolve to NodeFieldId from grammar
             for (&sym, &id) in ids {
-                if self.interner.resolve(sym) == field_name {
+                if self.ctx.interner.resolve(sym) == field_name {
                     return NonZeroU16::new(id.get());
                 }
             }
@@ -616,7 +618,7 @@ impl Compiler<'_> {
             None
         } else {
             // Unlinked mode: store StringId referencing the field name
-            let string_id = self.strings.intern_str(field_name);
+            let string_id = self.ctx.strings.borrow_mut().intern_str(field_name);
             Some(string_id.0)
         }
     }
@@ -643,7 +645,7 @@ impl Compiler<'_> {
 
         // Try string value first
         if let Some(str_token) = pred.string_value() {
-            let string_id = self.strings.intern_str(str_token.text());
+            let string_id = self.ctx.strings.borrow_mut().intern_str(str_token.text());
             return Some(PredicateIR::string(op, string_id));
         }
 
@@ -653,7 +655,7 @@ impl Compiler<'_> {
             let text: String = regex.as_cst().text().into();
             let without_prefix = text.strip_prefix('/').unwrap_or(&text);
             let pattern = without_prefix.strip_suffix('/').unwrap_or(without_prefix);
-            let string_id = self.strings.intern_str(pattern);
+            let string_id = self.ctx.strings.borrow_mut().intern_str(pattern);
             return Some(PredicateIR::regex(op, string_id));
         }
 
diff --git a/crates/plotnik-compiler/src/compile/mod.rs b/crates/plotnik-compiler/src/compile/mod.rs
index 5dc8633..31b3e69 100644
--- a/crates/plotnik-compiler/src/compile/mod.rs
+++ b/crates/plotnik-compiler/src/compile/mod.rs
@@ -16,12 +16,15 @@
 
 mod capture;
 mod compiler;
+mod dce;
+pub(crate) mod epsilon_elim;
 mod error;
 mod expressions;
 mod navigation;
 mod quantifier;
 mod scope;
 mod sequences;
+mod verify;
 
 #[cfg(test)]
 mod capture_tests;
@@ -29,5 +32,5 @@ mod capture_tests;
 mod compile_tests;
 
 pub use capture::CaptureEffects;
-pub use compiler::Compiler;
+pub use compiler::{CompileCtx, Compiler};
 pub use error::{CompileError, CompileResult};
diff --git a/crates/plotnik-compiler/src/compile/navigation.rs b/crates/plotnik-compiler/src/compile/navigation.rs
index 19d45cb..eb1881b 100644
--- a/crates/plotnik-compiler/src/compile/navigation.rs
+++ b/crates/plotnik-compiler/src/compile/navigation.rs
@@ -3,8 +3,8 @@
 //! Handles anchor-based navigation modes and navigation transformations
 //! for quantifier repeat iterations.
 
-use plotnik_bytecode::Nav;
 use crate::parser::{Expr, SeqItem};
+use plotnik_bytecode::Nav;
 
 // Re-export from parser for compile module consumers
 pub use crate::parser::is_truly_empty_scope;
diff --git a/crates/plotnik-compiler/src/compile/quantifier.rs b/crates/plotnik-compiler/src/compile/quantifier.rs
index a2fc843..5f1dc63 100644
--- a/crates/plotnik-compiler/src/compile/quantifier.rs
+++ b/crates/plotnik-compiler/src/compile/quantifier.rs
@@ -7,10 +7,10 @@
 //! - Whether skip/match need separate exits
 
 use crate::analyze::type_check::TypeId;
-use plotnik_bytecode::Nav;
 use crate::bytecode::{EffectIR, Label};
 use crate::parser::SyntaxKind;
 use crate::parser::ast::{self, Expr};
+use plotnik_bytecode::Nav;
 
 use super::Compiler;
 use super::capture::{CaptureEffects, check_needs_struct_wrapper, get_row_type_id};
@@ -403,9 +403,9 @@ impl Compiler<'_> {
 
         // Determine if struct wrapper is needed (once, here)
         let needs_struct_wrapper =
-            in_array_context && check_needs_struct_wrapper(inner, self.type_ctx);
+            in_array_context && check_needs_struct_wrapper(inner, self.ctx.type_ctx);
         let row_type_id = if in_array_context {
-            get_row_type_id(inner, self.type_ctx)
+            get_row_type_id(inner, self.ctx.type_ctx)
         } else {
             None
         };
diff --git a/crates/plotnik-compiler/src/compile/scope.rs b/crates/plotnik-compiler/src/compile/scope.rs
index 67484b5..9faf45a 100644
--- a/crates/plotnik-compiler/src/compile/scope.rs
+++ b/crates/plotnik-compiler/src/compile/scope.rs
@@ -6,8 +6,8 @@ use std::num::NonZeroU16;
 
 use crate::analyze::type_check::TypeId;
 use crate::bytecode::{CallIR, EffectIR, Label, MatchIR, MemberRef};
-use plotnik_bytecode::{EffectOpcode, Nav};
 use crate::parser::Expr;
+use plotnik_bytecode::{EffectOpcode, Nav};
 
 use super::Compiler;
 use super::capture::CaptureEffects;
@@ -44,9 +44,9 @@ impl Compiler<'_> {
     /// Uses (struct_type, relative_index) for deferred resolution.
     /// Member deduplication for call-site scoping will be added later.
     pub(super) fn lookup_member(&self, capture_name: &str, type_id: TypeId) -> Option<MemberRef> {
-        let fields = self.type_ctx.get_struct_fields(type_id)?;
+        let fields = self.ctx.type_ctx.get_struct_fields(type_id)?;
         for (relative_index, (&field_sym, _)) in fields.iter().enumerate() {
-            if self.interner.resolve(field_sym) == capture_name {
+            if self.ctx.interner.resolve(field_sym) == capture_name {
                 return Some(MemberRef::deferred_by_index(type_id, relative_index as u16));
             }
         }
diff --git a/crates/plotnik-compiler/src/compile/sequences.rs b/crates/plotnik-compiler/src/compile/sequences.rs
index 898a6c2..c00fa06 100644
--- a/crates/plotnik-compiler/src/compile/sequences.rs
+++ b/crates/plotnik-compiler/src/compile/sequences.rs
@@ -10,8 +10,8 @@ use plotnik_core::Symbol;
 
 use crate::analyze::type_check::{TypeId, TypeShape};
 use crate::bytecode::{EffectIR, Label, MemberRef};
-use plotnik_bytecode::{EffectOpcode, Nav};
 use crate::parser::ast::{self, Expr, SeqItem};
+use plotnik_bytecode::{EffectOpcode, Nav};
 
 use super::Compiler;
 use super::capture::CaptureEffects;
@@ -201,10 +201,11 @@ impl Compiler<'_> {
         // Get alternation's type info
         let alt_expr = Expr::AltExpr(alt.clone());
         let alt_type_id = self
+            .ctx
             .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 alt_type_shape = alt_type_id.and_then(|id| self.ctx.type_ctx.get_type(id));
 
         // Check if THIS alternation is syntactically tagged (all branches have labels).
         // This is distinct from whether the type is an Enum - a nested untagged alternation
@@ -224,7 +225,7 @@ impl Compiler<'_> {
                 .collect(),
             _ => BTreeMap::new(),
         };
-        let merged_fields = alt_type_id.and_then(|id| self.type_ctx.get_struct_fields(id));
+        let merged_fields = alt_type_id.and_then(|id| self.ctx.type_ctx.get_struct_fields(id));
 
         // Convert navigation to exact variant for alternation branches.
         // Branches should match at their exact cursor position only -
@@ -245,7 +246,7 @@ impl Compiler<'_> {
                 let label_text = label.text();
                 let (variant_idx, payload_type_id) = variant_info
                     .iter()
-                    .find(|(sym, _)| self.interner.resolve(**sym) == label_text)
+                    .find(|(sym, _)| self.ctx.interner.resolve(**sym) == label_text)
                     .map(|(_, &(idx, type_id))| (idx, type_id))
                     .expect("variant must exist for labeled branch");
 
@@ -277,7 +278,7 @@ impl Compiler<'_> {
                             .iter()
                             .enumerate()
                             .filter(|(_, (sym, _))| {
-                                !branch_captures.contains(self.interner.resolve(**sym))
+                                !branch_captures.contains(self.ctx.interner.resolve(**sym))
                             })
                             .flat_map(|(idx, _)| {
                                 [
diff --git a/crates/plotnik-compiler/src/compile/verify.rs b/crates/plotnik-compiler/src/compile/verify.rs
new file mode 100644
index 0000000..79fa7d1
--- /dev/null
+++ b/crates/plotnik-compiler/src/compile/verify.rs
@@ -0,0 +1,353 @@
+//! Debug-only semantic verification for IR.
+//!
+//! Compares semantic fingerprints derived from AST against compiled IR.
+//! Catches compilation bugs that change the sequence of navigation, effects, or matches.
+//! Zero-cost in release builds.
+
+use std::collections::BTreeSet;
+
+use indexmap::IndexMap;
+use plotnik_bytecode::Nav;
+use plotnik_core::Symbol;
+
+use crate::analyze::type_check::DefId;
+use crate::bytecode::{InstructionIR, Label, MatchIR, MemberRef, NodeTypeIR, PredicateValueIR};
+use crate::emit::StringTableBuilder;
+
+use super::compiler::CompileCtx;
+
+/// Semantic operation for fingerprinting.
+///
+/// Captures semantically significant operations while ignoring compilation artifacts
+/// like member indices, label addresses, and instruction sizes.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum SemanticOp {
+    /// Navigation (non-epsilon only, full detail preserved).
+    Nav(NavKind),
+
+    /// Named node match with optional type name.
+    MatchNamed(Option<String>),
+
+    /// Anonymous node match with optional literal value.
+    MatchAnon(Option<String>),
+
+    /// Any node wildcard (_).
+    MatchAny,
+
+    /// Field constraint.
+    Field(String),
+
+    /// Negated field constraint.
+    NegField(String),
+
+    /// Predicate with operation (as byte for Ord) and value.
+    Predicate(u8, String),
+
+    /// Effect with opcode (as byte for Ord) and optional member name.
+    Effect(u8, Option<String>),
+
+    /// Call to named definition.
+    Call(String),
+
+    /// Return from definition.
+    Return,
+
+    /// Cycle marker (back-edge in quantifier loop).
+    /// The index is the position in the path where the cycle returns to,
+    /// making it independent of specific bytecode labels.
+    CycleMarker(usize),
+}
+
+/// Navigation kind for fingerprinting.
+///
+/// Preserves full detail including Skip/Exact variants since these are semantically
+/// significant (determined by anchors).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum NavKind {
+    Stay,
+    StayExact,
+    Next,
+    NextSkip,
+    NextExact,
+    Down,
+    DownSkip,
+    DownExact,
+    Up(u8),
+    UpSkipTrivia(u8),
+    UpExact(u8),
+}
+
+impl From<Nav> for NavKind {
+    fn from(nav: Nav) -> Self {
+        match nav {
+            Nav::Epsilon => unreachable!("Epsilon should be filtered"),
+            Nav::Stay => Self::Stay,
+            Nav::StayExact => Self::StayExact,
+            Nav::Next => Self::Next,
+            Nav::NextSkip => Self::NextSkip,
+            Nav::NextExact => Self::NextExact,
+            Nav::Down => Self::Down,
+            Nav::DownSkip => Self::DownSkip,
+            Nav::DownExact => Self::DownExact,
+            Nav::Up(n) => Self::Up(n),
+            Nav::UpSkipTrivia(n) => Self::UpSkipTrivia(n),
+            Nav::UpExact(n) => Self::UpExact(n),
+        }
+    }
+}
+
+/// A semantic path: sequence of operations along one execution path.
+pub type Path = Vec<SemanticOp>;
+
+/// Fingerprint: set of all semantic paths through the IR.
+/// Using BTreeSet for deterministic ordering.
+pub type Fingerprint = BTreeSet<Path>;
+
+/// Collect semantic operations from a single MatchIR instruction.
+#[cfg(debug_assertions)]
+fn collect_ops_from_match(instr: &MatchIR, ctx: &CompileCtx) -> Vec<SemanticOp> {
+    let mut ops = Vec::new();
+
+    for e in &instr.pre_effects {
+        let name = resolve_member_name(&e.member_ref, ctx.interner);
+        ops.push(SemanticOp::Effect(e.opcode as u8, name));
+    }
+
+    // Epsilons are pure control flow - they don't navigate or check node types
+    if instr.nav != Nav::Epsilon {
+        ops.push(SemanticOp::Nav(instr.nav.into()));
+
+        // Only non-epsilons perform actual node type checks
+        match &instr.node_type {
+            NodeTypeIR::Any => ops.push(SemanticOp::MatchAny),
+            NodeTypeIR::Named(id) => {
+                let name = id.and_then(|i| resolve_node_type_name(i, ctx.node_types, ctx.interner));
+                ops.push(SemanticOp::MatchNamed(name));
+            }
+            NodeTypeIR::Anonymous(id) => {
+                let name = id.and_then(|i| resolve_node_type_name(i, ctx.node_types, ctx.interner));
+                ops.push(SemanticOp::MatchAnon(name));
+            }
+        }
+    }
+
+    if let Some(f) = instr.node_field {
+        let name = resolve_field_name(Some(f), ctx.node_fields, ctx.interner);
+        ops.push(SemanticOp::Field(
+            name.unwrap_or_else(|| format!("field#{}", f)),
+        ));
+    }
+
+    for &f in &instr.neg_fields {
+        let name = resolve_field_name(std::num::NonZeroU16::new(f), ctx.node_fields, ctx.interner);
+        ops.push(SemanticOp::NegField(
+            name.unwrap_or_else(|| format!("field#{}", f)),
+        ));
+    }
+
+    if let Some(p) = &instr.predicate {
+        let value = resolve_predicate_value(&p.value, &ctx.strings.borrow());
+        ops.push(SemanticOp::Predicate(p.op.to_byte(), value));
+    }
+
+    for e in &instr.post_effects {
+        let name = resolve_member_name(&e.member_ref, ctx.interner);
+        ops.push(SemanticOp::Effect(e.opcode as u8, name));
+    }
+
+    ops
+}
+
+/// Resolve member reference to field/variant name.
+#[cfg(debug_assertions)]
+fn resolve_member_name(
+    member_ref: &Option<MemberRef>,
+    interner: &plotnik_core::Interner,
+) -> Option<String> {
+    let Some(MemberRef::Deferred { field_name, .. }) = member_ref else {
+        return None;
+    };
+    interner.try_resolve(*field_name).map(|s| s.to_string())
+}
+
+/// Resolve node type ID to name.
+#[cfg(debug_assertions)]
+fn resolve_node_type_name(
+    id: std::num::NonZeroU16,
+    node_types: Option<&indexmap::IndexMap<Symbol, plotnik_core::NodeTypeId>>,
+    interner: &plotnik_core::Interner,
+) -> Option<String> {
+    let types = node_types?;
+    for (sym, type_id) in types {
+        if type_id.get() == id.get() {
+            return interner.try_resolve(*sym).map(|s| s.to_string());
+        }
+    }
+    None
+}
+
+/// Resolve field ID to name.
+#[cfg(debug_assertions)]
+fn resolve_field_name(
+    id: Option<std::num::NonZeroU16>,
+    node_fields: Option<&indexmap::IndexMap<Symbol, plotnik_core::NodeFieldId>>,
+    interner: &plotnik_core::Interner,
+) -> Option<String> {
+    let id = id?;
+    let fields = node_fields?;
+    for (sym, field_id) in fields {
+        if field_id.get() == id.get() {
+            return interner.try_resolve(*sym).map(|s| s.to_string());
+        }
+    }
+    None
+}
+
+/// Resolve predicate value to string.
+#[cfg(debug_assertions)]
+fn resolve_predicate_value(value: &PredicateValueIR, strings: &StringTableBuilder) -> String {
+    match value {
+        PredicateValueIR::String(id) => strings.get_str(*id).to_string(),
+        PredicateValueIR::Regex(id) => format!("/{}/", strings.get_str(*id)),
+    }
+}
+
+/// Build instruction lookup map from label to instruction.
+#[cfg(debug_assertions)]
+fn build_instruction_map(
+    instructions: &[InstructionIR],
+) -> std::collections::HashMap<Label, &InstructionIR> {
+    instructions.iter().map(|i| (i.label(), i)).collect()
+}
+
+/// Compute semantic fingerprint from IR via DFS.
+///
+/// Explores all paths from the entry label, collecting semantic operations.
+/// Cycles are detected per-path and marked with `CycleMarker(position)` where
+/// position is the index in the path where the cycle target's operations start.
+#[cfg(debug_assertions)]
+pub fn fingerprint_from_ir(
+    instructions: &[InstructionIR],
+    entry: Label,
+    def_entries: &IndexMap<DefId, Label>,
+    ctx: &CompileCtx,
+) -> Fingerprint {
+    let instr_map = build_instruction_map(instructions);
+
+    // Reverse map: Label -> DefId for resolving Call targets
+    let label_to_def: std::collections::HashMap<Label, DefId> = def_entries
+        .iter()
+        .map(|(&def_id, &label)| (label, def_id))
+        .collect();
+    let mut fingerprint = Fingerprint::new();
+
+    // DFS stack: (current_label, path_so_far, label_to_path_position)
+    // label_to_path_position maps labels to the path index where their ops started
+    let mut stack: Vec<(Label, Path, std::collections::HashMap<Label, usize>)> =
+        vec![(entry, Vec::new(), std::collections::HashMap::new())];
+
+    while let Some((current, mut path, mut label_positions)) = stack.pop() {
+        // Cycle detection: if we've seen this label, record position-based cycle marker
+        if let Some(&pos) = label_positions.get(&current) {
+            path.push(SemanticOp::CycleMarker(pos));
+            fingerprint.insert(path);
+            continue;
+        }
+
+        let Some(instr) = instr_map.get(&current) else {
+            // Dangling label — shouldn't happen, but record path anyway
+            fingerprint.insert(path);
+            continue;
+        };
+
+        // Effectless epsilons are invisible: don't mark visited, just pass through.
+        // This is "laser vision" for fingerprinting - we see through pure control flow.
+        if let InstructionIR::Match(m) = instr
+            && m.is_epsilon()
+            && m.pre_effects.is_empty()
+            && m.post_effects.is_empty()
+        {
+            for &succ in &m.successors {
+                stack.push((succ, path.clone(), label_positions.clone()));
+            }
+            continue;
+        }
+
+        // Record this label's position BEFORE adding ops
+        let current_pos = path.len();
+        label_positions.insert(current, current_pos);
+
+        match instr {
+            InstructionIR::Match(m) => {
+                let ops = collect_ops_from_match(m, ctx);
+                path.extend(ops);
+
+                if m.successors.is_empty() {
+                    // Terminal state (accept)
+                    fingerprint.insert(path);
+                } else {
+                    // Fork paths for each successor
+                    for &succ in &m.successors {
+                        stack.push((succ, path.clone(), label_positions.clone()));
+                    }
+                }
+            }
+            InstructionIR::Call(c) => {
+                // Record call with definition ID (stable across label rewrites)
+                let call_name = label_to_def
+                    .get(&c.target)
+                    .map(|def_id| format!("def#{}", def_id.as_u32()))
+                    .unwrap_or_else(|| format!("label#{}", c.target.0));
+                path.push(SemanticOp::Call(call_name));
+                stack.push((c.next, path, label_positions));
+            }
+            InstructionIR::Return(_) => {
+                path.push(SemanticOp::Return);
+                fingerprint.insert(path);
+            }
+            InstructionIR::Trampoline(t) => {
+                // Trampoline is part of preamble, skip semantically
+                stack.push((t.next, path, label_positions));
+            }
+        }
+    }
+
+    fingerprint
+}
+
+/// Debug-only semantic verification.
+///
+/// Panics with a detailed diagnostic if the IR fingerprint doesn't match expectations.
+/// This is a no-op in release builds.
+#[cfg(debug_assertions)]
+pub fn debug_verify_ir_fingerprint(
+    instructions: &[InstructionIR],
+    entry: Label,
+    def_entries: &IndexMap<DefId, Label>,
+    def_name: &str,
+    ctx: &CompileCtx,
+) {
+    let fingerprint = fingerprint_from_ir(instructions, entry, def_entries, ctx);
+
+    // For now, just compute and log the fingerprint.
+    // Full AST comparison will be added in a follow-up.
+    if std::env::var("PLOTNIK_DEBUG_FINGERPRINT").is_ok() {
+        eprintln!("=== Fingerprint for {} ===", def_name);
+        for (i, path) in fingerprint.iter().enumerate() {
+            eprintln!("Path {}: {:?}", i, path);
+        }
+        eprintln!("=== End fingerprint ===\n");
+    }
+}
+
+/// No-op in release builds.
+#[cfg(not(debug_assertions))]
+#[inline(always)]
+pub fn debug_verify_ir_fingerprint(
+    _instructions: &[InstructionIR],
+    _entry: Label,
+    _def_entries: &IndexMap<DefId, Label>,
+    _def_name: &str,
+    _ctx: &CompileCtx,
+) {
+}
diff --git a/crates/plotnik-compiler/src/diagnostics/message.rs b/crates/plotnik-compiler/src/diagnostics/message.rs
index 5606476..0796a4d 100644
--- a/crates/plotnik-compiler/src/diagnostics/message.rs
+++ b/crates/plotnik-compiler/src/diagnostics/message.rs
@@ -126,7 +126,10 @@ impl DiagnosticKind {
     pub fn is_structural_error(&self) -> bool {
         matches!(
             self,
-            Self::UnclosedTree | Self::UnclosedSequence | Self::UnclosedAlternation | Self::UnclosedRegex
+            Self::UnclosedTree
+                | Self::UnclosedSequence
+                | Self::UnclosedAlternation
+                | Self::UnclosedRegex
         )
     }
 
@@ -261,7 +264,9 @@ impl DiagnosticKind {
             Self::IncompatibleStructShapes => "incompatible struct shapes",
 
             // Predicate validation
-            Self::PredicateOnNonLeaf => "predicates match text content, but this node can contain children",
+            Self::PredicateOnNonLeaf => {
+                "predicates match text content, but this node can contain children"
+            }
             Self::EmptyRegex => "empty regex pattern",
             Self::RegexBackreference => "backreferences are not supported in regex",
             Self::RegexLookaround => "lookahead/lookbehind is not supported in regex",
diff --git a/crates/plotnik-compiler/src/emit/emitter.rs b/crates/plotnik-compiler/src/emit/emitter.rs
index 74ef4ad..ca8b160 100644
--- a/crates/plotnik-compiler/src/emit/emitter.rs
+++ b/crates/plotnik-compiler/src/emit/emitter.rs
@@ -1,12 +1,14 @@
 //! Core bytecode emission logic.
 
+use std::cell::RefCell;
+
 use plotnik_core::Symbol;
 
 use crate::analyze::type_check::TypeId;
 use crate::bytecode::{InstructionIR, Label, PredicateValueIR};
-use plotnik_bytecode::{Entrypoint, FieldSymbol, Header, NodeSymbol, SECTION_ALIGN, TriviaEntry};
-use crate::compile::Compiler;
+use crate::compile::{CompileCtx, Compiler};
 use crate::query::LinkedQuery;
+use plotnik_bytecode::{Entrypoint, FieldSymbol, Header, NodeSymbol, SECTION_ALIGN, TriviaEntry};
 
 use super::EmitError;
 use super::layout::CacheAligned;
@@ -22,19 +24,19 @@ pub fn emit(query: &LinkedQuery) -> Result<Vec<u8>, EmitError> {
     let node_type_ids = query.node_type_ids();
     let node_field_ids = query.node_field_ids();
 
-    let mut strings = StringTableBuilder::new();
+    let strings = RefCell::new(StringTableBuilder::new());
     let mut types = TypeTableBuilder::new();
-    types.build(type_ctx, interner, &mut strings)?;
+    types.build(type_ctx, interner, &mut strings.borrow_mut())?;
 
-    let compile_result = Compiler::compile(
+    let ctx = CompileCtx {
         interner,
         type_ctx,
         symbol_table,
-        &mut strings,
-        Some(node_type_ids),
-        Some(node_field_ids),
-    )
-    .map_err(EmitError::Compile)?;
+        strings: &strings,
+        node_types: Some(node_type_ids),
+        node_fields: Some(node_field_ids),
+    };
+    let compile_result = Compiler::compile(&ctx).map_err(EmitError::Compile)?;
 
     // Layout with cache alignment
     // Preamble entry FIRST ensures it gets the lowest address (step 0)
@@ -50,14 +52,14 @@ pub fn emit(query: &LinkedQuery) -> Result<Vec<u8>, EmitError> {
     // Collect node symbols
     let mut node_symbols: Vec<NodeSymbol> = Vec::new();
     for (&sym, &node_id) in node_type_ids {
-        let name = strings.get_or_intern(sym, interner)?;
+        let name = strings.borrow_mut().get_or_intern(sym, interner)?;
         node_symbols.push(NodeSymbol::new(node_id.get(), name));
     }
 
     // Collect field symbols
     let mut field_symbols: Vec<FieldSymbol> = Vec::new();
     for (&sym, &field_id) in node_field_ids {
-        let name = strings.get_or_intern(sym, interner)?;
+        let name = strings.borrow_mut().get_or_intern(sym, interner)?;
         field_symbols.push(FieldSymbol::new(field_id.get(), name));
     }
 
@@ -65,7 +67,7 @@ pub fn emit(query: &LinkedQuery) -> Result<Vec<u8>, EmitError> {
     let mut entrypoints: Vec<Entrypoint> = Vec::new();
     for (def_id, type_id) in type_ctx.iter_def_types() {
         let name_sym = type_ctx.def_name_sym(def_id);
-        let name = strings.get_or_intern(name_sym, interner)?;
+        let name = strings.borrow_mut().get_or_intern(name_sym, interner)?;
         let result_type = types.resolve_type(type_id, type_ctx)?;
 
         // Get actual target from compiled result
@@ -79,6 +81,9 @@ pub fn emit(query: &LinkedQuery) -> Result<Vec<u8>, EmitError> {
         entrypoints.push(Entrypoint::new(name, target, result_type));
     }
 
+    // Move strings out of RefCell for final emission
+    let strings = strings.into_inner();
+
     // Validate counts
     strings.validate()?;
     types.validate()?;
@@ -95,8 +100,13 @@ pub fn emit(query: &LinkedQuery) -> Result<Vec<u8>, EmitError> {
     regexes.validate()?;
 
     // Resolve and serialize transitions
-    let transitions_bytes =
-        emit_transitions(&compile_result.instructions, &layout, &types, &strings, &regexes);
+    let transitions_bytes = emit_transitions(
+        &compile_result.instructions,
+        &layout,
+        &types,
+        &strings,
+        &regexes,
+    );
 
     // Emit all byte sections
     let (str_blob, str_table) = strings.emit();
@@ -191,7 +201,12 @@ fn emit_transitions(
         };
 
         let offset = step_id as usize * 8; // STEP_SIZE
-        let resolved = instr.resolve(&layout.label_to_step, lookup_member, get_member_base, lookup_regex);
+        let resolved = instr.resolve(
+            &layout.label_to_step,
+            lookup_member,
+            get_member_base,
+            lookup_regex,
+        );
 
         // Copy instruction bytes to the correct position
         let end = offset + resolved.len();
diff --git a/crates/plotnik-compiler/src/emit/layout_tests.rs b/crates/plotnik-compiler/src/emit/layout_tests.rs
index ec7d9bc..7735010 100644
--- a/crates/plotnik-compiler/src/emit/layout_tests.rs
+++ b/crates/plotnik-compiler/src/emit/layout_tests.rs
@@ -1,8 +1,8 @@
 use std::num::NonZeroU16;
 
 use super::layout::CacheAligned;
-use plotnik_bytecode::Nav;
 use crate::bytecode::{CallIR, EffectIR, Label, MatchIR, NodeTypeIR, ReturnIR};
+use plotnik_bytecode::Nav;
 
 #[test]
 fn layout_empty() {
diff --git a/crates/plotnik-compiler/src/emit/mod.rs b/crates/plotnik-compiler/src/emit/mod.rs
index 8242d75..026c9a6 100644
--- a/crates/plotnik-compiler/src/emit/mod.rs
+++ b/crates/plotnik-compiler/src/emit/mod.rs
@@ -18,14 +18,14 @@ mod emit_tests;
 #[cfg(test)]
 mod layout_tests;
 #[cfg(test)]
-mod string_table_tests;
-#[cfg(test)]
 mod regex_table_tests;
 #[cfg(test)]
+mod string_table_tests;
+#[cfg(test)]
 mod type_table_tests;
 
 pub use emitter::emit;
 pub use error::EmitError;
-pub use regex_table::{deserialize_dfa, RegexTableBuilder};
+pub use regex_table::{RegexTableBuilder, deserialize_dfa};
 pub use string_table::StringTableBuilder;
 pub use type_table::TypeTableBuilder;
diff --git a/crates/plotnik-compiler/src/emit/regex_table_tests.rs b/crates/plotnik-compiler/src/emit/regex_table_tests.rs
index 9fd5b13..64c5b4c 100644
--- a/crates/plotnik-compiler/src/emit/regex_table_tests.rs
+++ b/crates/plotnik-compiler/src/emit/regex_table_tests.rs
@@ -1,7 +1,7 @@
-use super::regex_table::{deserialize_dfa, RegexTableBuilder};
+use super::regex_table::{RegexTableBuilder, deserialize_dfa};
 use plotnik_bytecode::StringId;
-use regex_automata::dfa::Automaton;
 use regex_automata::Input;
+use regex_automata::dfa::Automaton;
 
 #[test]
 fn intern_and_lookup() {
@@ -46,8 +46,18 @@ fn emit_and_deserialize() {
 
     // Deserialize and test first regex
     let dfa1 = deserialize_dfa(&blob[offset1..offset2]).unwrap();
-    assert!(dfa1.try_search_fwd(&Input::new("hello")).ok().flatten().is_some());
-    assert!(dfa1.try_search_fwd(&Input::new("world")).ok().flatten().is_none());
+    assert!(
+        dfa1.try_search_fwd(&Input::new("hello"))
+            .ok()
+            .flatten()
+            .is_some()
+    );
+    assert!(
+        dfa1.try_search_fwd(&Input::new("world"))
+            .ok()
+            .flatten()
+            .is_none()
+    );
 }
 
 #[test]
@@ -64,8 +74,18 @@ fn escaped_slash_pattern() {
     let offset2 = u32::from_le_bytes([table[20], table[21], table[22], table[23]]) as usize;
 
     let dfa = deserialize_dfa(&blob[offset1..offset2]).unwrap();
-    assert!(dfa.try_search_fwd(&Input::new("a/b")).ok().flatten().is_some());
-    assert!(dfa.try_search_fwd(&Input::new("ab")).ok().flatten().is_none());
+    assert!(
+        dfa.try_search_fwd(&Input::new("a/b"))
+            .ok()
+            .flatten()
+            .is_some()
+    );
+    assert!(
+        dfa.try_search_fwd(&Input::new("ab"))
+            .ok()
+            .flatten()
+            .is_none()
+    );
 }
 
 #[test]
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_captured.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_captured.snap
index 685be83..5928966 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_captured.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_captured.snap
@@ -31,9 +31,7 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    11, 13
-  10                                        ▶
-  11   !   (identifier) [Node Set(M0)]      10
-  13   !   (number) [Node Set(M0)]          10
+  06   ε                                    09, 11
+  08                                        ▶
+  09   !   (identifier) [Node Set(M0)]      08
+  11   !   (number) [Node Set(M0)]          08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_captured_tagged.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_captured_tagged.snap
index 832a8dd..4dd8c80 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_captured_tagged.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_captured_tagged.snap
@@ -42,10 +42,7 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    13, 16
-  10                                        ▶
-  11   ε   [Set(M4)]                        10
-  13   !   [Enum(M2)] (identifier) [Node Set(M0) EndEnum]  11
-  16   !   [Enum(M3)] (number) [Node Set(M1) EndEnum]  11
+  06   ε                                    09, 12
+  08                                        ▶
+  09   !   [Enum(M2)] (identifier) [Node Set(M0) EndEnum Set(M4)]  08
+  12   !   [Enum(M3)] (number) [Node Set(M1) EndEnum Set(M4)]  08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_in_quantifier.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_in_quantifier.snap
index 37d78bf..db42c8c 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_in_quantifier.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_in_quantifier.snap
@@ -47,29 +47,18 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (object)                         08
-  08   ε   [Arr]                            10
-  10   ε                                    42, 21
-  12   ε   [EndArr Set(M5)]                 14
-  14   △   _                                20
-  15  ...  
-  16   ε   [EndObj Push]                    18
-  18   ε                                    48, 12
-  20                                        ▶
-  21   ε   [EndArr Set(M5)]                 20
-  23  ...  
-  24   ε   [Set(M4)]                        16
-  26   !   [Enum(M2)] (pair) [Node Set(M0) EndEnum]  24
-  29   !   [Enum(M3)] (shorthand_property_identifier) [Node Set(M1) EndEnum]  24
-  32   ε                                    26, 29
-  34   ε   [Obj]                            32
-  36   ▷   _                                40
-  37   ε                                    36, 12
-  39  ...  
-  40   ε                                    34, 37
-  42   ▽   _                                40
-  43   ▷   _                                46
-  44   ε                                    43, 12
-  46   ε                                    34, 44
-  48   ▷   _                                46
+  06   !   (object)                         08
+  07  ...  
+  08   ε   [Arr]                            26, 12
+  10                                        ▶
+  11   ε                                    32
+  12   ε   [EndArr Set(M5)]                 10
+  14   ε   [EndObj Push]                    30, 11
+  16   !   [Enum(M2)] (pair) [Node Set(M0) EndEnum Set(M4)]  14
+  19   !   [Enum(M3)] (shorthand_property_identifier) [Node Set(M1) EndEnum Set(M4)]  14
+  22   ε   [Obj]                            16, 19
+  24   ▷   _                                22, 24, 32
+  26   ▽   _                                22, 24, 32
+  28   ▷   _                                22, 28, 32
+  30   ▷   _                                22, 28, 32
+  32   △   [EndArr Set(M5)] _               10
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_labeled.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_labeled.snap
index 318de28..9728bdd 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_labeled.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_labeled.snap
@@ -42,11 +42,7 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    11, 16
-  10                                        ▶
-  11   !   [Enum(M2)] (identifier) [Node Set(M0) EndEnum]  10
-  14  ...  
-  15  ...  
-  16   !   [Enum(M3)] (number) [Node Set(M1) EndEnum]  10
+  06   ε                                    09, 12
+  08                                        ▶
+  09   !   [Enum(M2)] (identifier) [Node Set(M0) EndEnum]  08
+  12   !   [Enum(M3)] (number) [Node Set(M1) EndEnum]  08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_no_internal_captures.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_no_internal_captures.snap
index 85da4ce..798ff20 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_no_internal_captures.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_no_internal_captures.snap
@@ -32,10 +32,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (program)                        08
-  08   ε                                    11, 13
-  10                                        ▶
-  11 !!▽   (identifier) [Node Set(M0)]      15
-  13 !!▽   (number) [Node Set(M0)]          15
-  15   △   _                                10
+  06   !   (program)                        09, 11
+  08                                        ▶
+  09 !!▽   (identifier) [Node Set(M0)]      13
+  11 !!▽   (number) [Node Set(M0)]          13
+  13   △   _                                08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_null_injection.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_null_injection.snap
index 44d6f57..d05a2fc 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_null_injection.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_null_injection.snap
@@ -38,11 +38,7 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    11, 16
-  10                                        ▶
-  11   !   [Null Set(M1)] (identifier) [Node Set(M0)]  10
-  14  ...  
-  15  ...  
-  16   !   [Null Set(M0)] (number) [Node Set(M1)]  10
+  06   ε                                    09, 12
+  08                                        ▶
+  09   !   [Null Set(M1)] (identifier) [Node Set(M0)]  08
+  12   !   [Null Set(M0)] (number) [Node Set(M1)]  08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_tagged_in_field_constraint.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_tagged_in_field_constraint.snap
index 0658e26..f3f45e2 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_tagged_in_field_constraint.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_tagged_in_field_constraint.snap
@@ -42,12 +42,10 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (pair)                           08
-  08   ▽   key: _                           09
-  09   ε                                    12, 16
-  11                                        ▶
-  12   !   [Enum(M1)] (identifier) [Node Set(M0) EndEnum Set(M3)]  18
-  15  ...  
-  16   !   [Enum(M2)] (number) [EndEnum Set(M3)]  18
-  18   △   _                                11
+  06   !   (pair)                           08
+  07  ...  
+  08   ▽   key: _                           11, 14
+  10                                        ▶
+  11   !   [Enum(M1)] (identifier) [Node Set(M0) EndEnum Set(M3)]  16
+  14   !   [Enum(M2)] (number) [EndEnum Set(M3)]  16
+  16   △   _                                10
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_tagged_with_definition_ref.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_tagged_with_definition_ref.snap
index de5ce91..2620bb7 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_tagged_with_definition_ref.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_tagged_with_definition_ref.snap
@@ -36,7 +36,7 @@ N1: S7 → T4  ; Test
 
 [entrypoints]
 Inner = 06 :: T1
-Test  = 11 :: T4
+Test  = 09 :: T4
 
 [transitions]
 _ObjWrap:
@@ -46,21 +46,17 @@ _ObjWrap:
   05                                        ▶
 
 Inner:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Node Set(M0)]      10
-  10                                        ▶
+  06   !   (identifier) [Node Set(M0)]      08
+  08                                        ▶
 
 Test:
-  11   ε                                    12
-  12   ε                                    26, 28
-  14                                        ▶
-  15  ...  
-  16   ε   [Set(M4)]                        14
-  18   ε   [EndEnum]                        16
-  20   ε   [EndObj]                         18
-  22   !   (Inner)                          06 : 20
+  09   ε                                    21, 24
+  11                                        ▶
+  12   ε   [Set(M4)]                        11
+  14   ε   [EndEnum]                        12
+  16   ε   [EndObj]                         14
+  18   !   (Inner)                          06 : 16
+  19   ε   [Obj]                            18
+  21   ε   [Enum(M2)]                       19
   23  ...  
-  24   ε   [Obj]                            22
-  26   ε   [Enum(M2)]                       24
-  28   !   [Enum(M3)] (number) [Node Set(M1) EndEnum]  16
+  24   !   [Enum(M3)] (number) [Node Set(M1) EndEnum Set(M4)]  11
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_unlabeled.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_unlabeled.snap
index 0200d2f..a1d05a5 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_unlabeled.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__alternations_unlabeled.snap
@@ -38,11 +38,7 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    11, 16
-  10                                        ▶
-  11   !   [Null Set(M1)] (identifier) [Node Set(M0)]  10
-  14  ...  
-  15  ...  
-  16   !   [Null Set(M0)] (string) [Node Set(M1)]  10
+  06   ε                                    09, 12
+  08                                        ▶
+  09   !   [Null Set(M1)] (identifier) [Node Set(M0)]  08
+  12   !   [Null Set(M0)] (string) [Node Set(M1)]  08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_between_siblings.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_between_siblings.snap
index f50ec90..5e8275b 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_between_siblings.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_between_siblings.snap
@@ -29,9 +29,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08   ▽   (identifier)                     09
-  09  !▷   (number)                         10
-  10   △   _                                11
-  11                                        ▶
+  06   !   (array)                          07
+  07   ▽   (identifier)                     08
+  08  !▷   (number)                         09
+  09   △   _                                10
+  10                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_first_child.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_first_child.snap
index 5d8a8dd..3acdf64 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_first_child.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_first_child.snap
@@ -18,18 +18,17 @@ T0 = <Void>
 N0: S1 → T0  ; Test
 
 [entrypoints]
-Test = 06 :: T0
+Test = 6 :: T0
 
 [transitions]
 _ObjWrap:
-  00   ε   [Obj]                            02
-  02       Trampoline                       03
-  03   ε   [EndObj]                         05
-  05                                        ▶
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08  !▽   (identifier)                     09
-  09   △   _                                10
-  10                                        ▶
+  6   !   (array)                           7
+  7  !▽   (identifier)                      8
+  8   △   _                                 9
+  9                                         ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_last_child.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_last_child.snap
index 4e64317..30f979a 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_last_child.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_last_child.snap
@@ -28,11 +28,10 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08   ▽   _                                13
-  09                                        ▶
-  10  !△   _                                09
-  11   !   (identifier)                     10
-  12   ▷   _                                13
-  13   ε                                    11, 12
+  06   !   (array)                          08
+  07  ...  
+  08   ▽   _                                12, 13
+  10                                        ▶
+  11  !△   _                                10
+  12   !   (identifier)                     11
+  13   ▷   _                                12, 13
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_no_anchor.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_no_anchor.snap
index 1f5f032..753deab 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_no_anchor.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_no_anchor.snap
@@ -29,9 +29,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08   ▽   (identifier)                     09
-  09   ▷   (number)                         10
-  10   △   _                                11
-  11                                        ▶
+  06   !   (array)                          07
+  07   ▽   (identifier)                     08
+  08   ▷   (number)                         09
+  09   △   _                                10
+  10                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_with_anonymous.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_with_anonymous.snap
index 908e94e..34d9153 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_with_anonymous.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__anchors_with_anonymous.snap
@@ -29,9 +29,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (binary_expression)              08
-  08   ▽   "+"                              09
-  09 !!▷   (identifier)                     10
-  10   △   _                                11
-  11                                        ▶
+  06   !   (binary_expression)              07
+  07   ▽   "+"                              08
+  08 !!▷   (identifier)                     09
+  09   △   _                                10
+  10                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_basic.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_basic.snap
index 2e9b221..ff3a971 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_basic.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_basic.snap
@@ -20,17 +20,15 @@ M0: S1 → T0  ; name: <Node>
 N0: S2 → T1  ; Test
 
 [entrypoints]
-Test = 06 :: T1
+Test = 6 :: T1
 
 [transitions]
 _ObjWrap:
-  00   ε   [Obj]                            02
-  02       Trampoline                       03
-  03   ε   [EndObj]                         05
-  05                                        ▶
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Node Set(M0)]      10
-  10                                        ▶
+  6   !   (identifier) [Node Set(M0)]       8
+  8                                         ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_deeply_nested.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_deeply_nested.snap
index 579fe49..8b77769 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_deeply_nested.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_deeply_nested.snap
@@ -46,13 +46,11 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   (array) [Node Set(M0)]           10
-  10   ▽   (array) [Node Set(M1)]           12
-  12   ▽   (array) [Node Set(M2)]           14
-  14   ▽   (identifier) [Node Set(M3)]      16
+  06   !   (array) [Node Set(M0)]           08
+  08   ▽   (array) [Node Set(M1)]           10
+  10   ▽   (array) [Node Set(M2)]           12
+  12   ▽   (identifier) [Node Set(M3)]      14
+  14   △   _                                15
+  15   △   _                                16
   16   △   _                                17
-  17   △   _                                18
-  18   △   _                                19
-  19                                        ▶
+  17                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_enum_with_type_annotation.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_enum_with_type_annotation.snap
index bb97653..69ab7cf 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_enum_with_type_annotation.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_enum_with_type_annotation.snap
@@ -44,10 +44,7 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    13, 16
-  10                                        ▶
-  11   ε   [Set(M4)]                        10
-  13   !   [Enum(M2)] (identifier) [Node Set(M0) EndEnum]  11
-  16   !   [Enum(M3)] (number) [Node Set(M1) EndEnum]  11
+  06   ε                                    09, 12
+  08                                        ▶
+  09   !   [Enum(M2)] (identifier) [Node Set(M0) EndEnum Set(M4)]  08
+  12   !   [Enum(M3)] (number) [Node Set(M1) EndEnum Set(M4)]  08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_multiple.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_multiple.snap
index 4fb204b..2e4e2f3 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_multiple.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_multiple.snap
@@ -38,8 +38,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (binary_expression)              08
+  06   !   (binary_expression)              08
+  07  ...  
   08   ▽   (identifier) [Node Set(M0)]      10
   10   ▷   (number) [Node Set(M1)]          12
   12   △   _                                13
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_nested_flat.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_nested_flat.snap
index b914d6d..004db2b 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_nested_flat.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_nested_flat.snap
@@ -40,11 +40,9 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   (array) [Node Set(M0)]           10
-  10   ▽   (array) [Node Set(M1)]           12
-  12   ▽   (identifier) [Node Set(M2)]      14
-  14   △   _                                15
-  15   △   _                                16
-  16                                        ▶
+  06   !   (array) [Node Set(M0)]           08
+  08   ▽   (array) [Node Set(M1)]           10
+  10   ▽   (identifier) [Node Set(M2)]      12
+  12   △   _                                13
+  13   △   _                                14
+  14                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_optional_wrapper_struct.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_optional_wrapper_struct.snap
index a8c20b6..c371d72 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_optional_wrapper_struct.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_optional_wrapper_struct.snap
@@ -40,18 +40,10 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε   [Obj]                            10
-  10   ε                                    29, 22
-  12                                        ▶
-  13   ε   [EndObj Set(M2)]                 12
-  15  ...  
-  16   ε   [EndObj Set(M1)]                 13
-  18   !   (identifier) [Node Set(M0)]      16
-  20   ε   [Obj]                            18
-  22   ε   [Null Set(M1)]                   13
-  24   ▷   _                                27
-  25   ε                                    24, 22
-  27   ε                                    20, 25
-  29   !   _                                27
+  06   ε   [Obj]                            18, 14
+  08                                        ▶
+  09   ε   [EndObj Set(M2)]                 08
+  11   !   [Obj] (identifier) [Node Set(M0) EndObj Set(M1) EndObj Set(M2)]  08
+  14   ε   [Null Set(M1)]                   09
+  16   ▷   _                                11, 16, 14
+  18   !   _                                11, 16, 14
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_struct_scope.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_struct_scope.snap
index c395768..340c474 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_struct_scope.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_struct_scope.snap
@@ -40,10 +40,6 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε   [Obj]                            10
-  10   !   (identifier) [Node Set(M0)]      12
-  12   ▷   (number) [Node Set(M1)]          14
-  14   ε   [EndObj Set(M2)]                 16
-  16                                        ▶
+  06   !   [Obj] (identifier) [Node Set(M0)]  08
+  08   ▷   (number) [Node Set(M1) EndObj Set(M2)]  11
+  11                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_struct_with_type_annotation.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_struct_with_type_annotation.snap
index 3b5695a..fa48959 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_struct_with_type_annotation.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_struct_with_type_annotation.snap
@@ -25,7 +25,7 @@ N0: S3 → T2  ; Test
 N1: S4 → T1  ; FunctionInfo
 
 [entrypoints]
-Test = 06 :: T2
+Test = 08 :: T2
 
 [transitions]
 _ObjWrap:
@@ -33,11 +33,9 @@ _ObjWrap:
   02       Trampoline                       03
   03   ε   [EndObj]                         05
   05                                        ▶
+  06  ...  
+  07  ...  
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε   [Obj]                            10
-  10   !   (identifier) [Node Set(M0)]      12
-  12   ε   [EndObj Set(M1)]                 14
-  14                                        ▶
+  08   !   [Obj] (identifier) [Node Set(M0) EndObj Set(M1)]  11
+  11                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_with_type_custom.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_with_type_custom.snap
index 03da224..e09118c 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_with_type_custom.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_with_type_custom.snap
@@ -23,17 +23,15 @@ N0: S1 → T1  ; Identifier
 N1: S3 → T2  ; Test
 
 [entrypoints]
-Test = 06 :: T2
+Test = 6 :: T2
 
 [transitions]
 _ObjWrap:
-  00   ε   [Obj]                            02
-  02       Trampoline                       03
-  03   ε   [EndObj]                         05
-  05                                        ▶
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Node Set(M0)]      10
-  10                                        ▶
+  6   !   (identifier) [Node Set(M0)]       8
+  8                                         ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_with_type_string.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_with_type_string.snap
index 03434cc..acbb251 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_with_type_string.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_with_type_string.snap
@@ -20,17 +20,15 @@ M0: S1 → T0  ; name: <String>
 N0: S2 → T1  ; Test
 
 [entrypoints]
-Test = 06 :: T1
+Test = 6 :: T1
 
 [transitions]
 _ObjWrap:
-  00   ε   [Obj]                            02
-  02       Trampoline                       03
-  03   ε   [EndObj]                         05
-  05                                        ▶
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Text Set(M0)]      10
-  10                                        ▶
+  6   !   (identifier) [Text Set(M0)]       8
+  8                                         ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_wrapper_struct.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_wrapper_struct.snap
index f11c39c..bf16c41 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_wrapper_struct.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__captures_wrapper_struct.snap
@@ -44,26 +44,16 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε   [Arr]                            10
-  10   ε                                    36, 17
-  12   ε   [EndObj Push]                    14
-  14   ε                                    42, 17
-  16                                        ▶
-  17   ε   [EndArr Set(M3)]                 16
-  19   ε   [EndObj Set(M2)]                 12
-  21   ▷   (number) [Node Set(M1)]          19
+  06   ε   [Arr]                            24, 09
+  08                                        ▶
+  09   ε   [EndArr Set(M3)]                 08
+  11   ε   [EndObj Push]                    28, 09
+  13   ▷   (number) [Node Set(M1) EndObj Set(M2)]  11
+  16   !   [Obj] (identifier) [Node Set(M0)]  13
+  18   ε                                    16
+  19   ε   [Obj]                            18
+  21   ▷   _                                19, 21, 09
   23  ...  
-  24   !   (identifier) [Node Set(M0)]      21
-  26   ε   [Obj]                            24
-  28   ε   [Obj]                            26
-  30   ▷   _                                34
-  31  ...  
-  32   ε                                    30, 17
-  34   ε                                    28, 32
-  36   !   _                                34
-  37   ▷   _                                40
-  38   ε                                    37, 17
-  40   ε                                    28, 38
-  42   ▷   _                                40
+  24   !   _                                19, 21, 09
+  26   ▷   _                                19, 26, 09
+  28   ▷   _                                19, 26, 09
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__comprehensive_multi_definition.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__comprehensive_multi_definition.snap
index 26b8b29..cf7a194 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__comprehensive_multi_definition.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__comprehensive_multi_definition.snap
@@ -54,8 +54,8 @@ N1: S07 → T05  ; Expression
 N2: S08 → T06  ; Assignment
 
 [entrypoints]
-Assignment = 14 :: T06
-Expression = 11 :: T05
+Assignment = 11 :: T06
+Expression = 09 :: T05
 Ident      = 06 :: T02
 
 [transitions]
@@ -66,23 +66,20 @@ _ObjWrap:
   05                                        ▶
 
 Ident:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Text Set(M0)]      10
-  10                                        ▶
+  06   !   (identifier) [Text Set(M0)]      08
+  08                                        ▶
 
 Expression:
-  11   ε                                    12
-  12   ε                                    24, 27
+  09   ε                                    20, 24
 
 Assignment:
-  14   ε                                    15
-  15   !   (assignment_expression)          16
-  16   ▽   left: (identifier) [Node Set(M6)]  18
-  18   ▷   right: (Expression)              11 : 19
-  19   ε   [Set(M5)]                        21
-  21   △   _                                22
-  22                                        ▶
-  23                                        ▶
-  24   !   [Enum(M3)] (number) [Node Set(M1) EndEnum]  23
-  27   !   [Enum(M4)] (identifier) [Node Set(M2) EndEnum]  23
+  11   !   (assignment_expression)          12
+  12   ▽   left: (identifier) [Node Set(M6)]  14
+  14   ▷   right: (Expression)              09 : 16
+  15  ...  
+  16   △   [Set(M5)] _                      18
+  18                                        ▶
+  19                                        ▶
+  20   !   [Enum(M3)] (number) [Node Set(M1) EndEnum]  19
+  23  ...  
+  24   !   [Enum(M4)] (identifier) [Node Set(M2) EndEnum]  19
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_multiple.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_multiple.snap
index 19b1e0b..0003b3d 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_multiple.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_multiple.snap
@@ -27,7 +27,7 @@ N0: S3 → T1  ; Foo
 N1: S4 → T2  ; Bar
 
 [entrypoints]
-Bar = 11 :: T2
+Bar = 09 :: T2
 Foo = 06 :: T1
 
 [transitions]
@@ -38,12 +38,9 @@ _ObjWrap:
   05                                        ▶
 
 Foo:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Node Set(M0)]      10
-  10                                        ▶
+  06   !   (identifier) [Node Set(M0)]      08
+  08                                        ▶
 
 Bar:
-  11   ε                                    12
-  12   !   (string) [Node Set(M1)]          14
-  14                                        ▶
+  09   !   (string) [Node Set(M1)]          11
+  11                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_nested_capture.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_nested_capture.snap
index 271ba52..b86bf49 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_nested_capture.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_nested_capture.snap
@@ -43,35 +43,28 @@ _ObjWrap:
   05                                        ▶
 
 Inner:
-  06   ε                                    07
-  07   !   (call_expression)                08
+  06   !   (call_expression)                08
+  07  ...  
   08   ▽   (identifier) [Node Set(M0)]      10
   10   △   _                                11
   11                                        ▶
 
 Outer:
-  12   ε                                    13
-  13   !   (array)                          14
-  14   ε   [Arr]                            16
-  16   ε                                    44, 27
-  18   ε   [EndArr Set(M2)]                 20
-  20   △   _                                26
-  21   ε   [EndObj Push]                    24
+  12   !   (array)                          13
+  13   ε   [Arr]                            34, 17
+  15                                        ▶
+  16   ε                                    40
+  17   ε   [EndArr Set(M2)]                 15
+  19   ε   [EndObj Push]                    38, 16
+  21   ε   [Set(M1)]                        19
   23  ...  
-  24   ε                                    50, 18
-  26                                        ▶
-  27   ε   [EndArr Set(M2)]                 26
-  29   ε   [Set(M1)]                        21
+  24   ε   [EndObj]                         21
+  26   !   (Inner)                          06 : 24
+  27   ε   [Obj]                            26
+  29   ε   [Obj]                            27
   31  ...  
-  32   ε   [EndObj]                         29
-  34   !   (Inner)                          06 : 32
-  35   ε   [Obj]                            34
-  37   ε   [Obj]                            35
-  39   ▷   _                                42
-  40   ε                                    39, 18
-  42   ε                                    37, 40
-  44   ▽   _                                42
-  45   ▷   _                                48
-  46   ε                                    45, 18
-  48   ε                                    37, 46
-  50   ▷   _                                48
+  32   ▷   _                                29, 32, 40
+  34   ▽   _                                29, 32, 40
+  36   ▷   _                                29, 36, 40
+  38   ▷   _                                29, 36, 40
+  40   △   [EndArr Set(M2)] _               15
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_reference.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_reference.snap
index 5690d11..c33c425 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_reference.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_reference.snap
@@ -33,7 +33,7 @@ N1: S4 → T2  ; Root
 
 [entrypoints]
 Expression = 06 :: T1
-Root       = 10 :: T2
+Root       = 08 :: T2
 
 [transitions]
 _ObjWrap:
@@ -43,16 +43,15 @@ _ObjWrap:
   05                                        ▶
 
 Expression:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    17, 20
+  06   ε                                    16, 19
 
 Root:
-  10   ε                                    11
-  11   !   (function_declaration)           12
-  12   ▽   name: (identifier) [Node Set(M2)]  14
-  14   △   _                                15
-  15                                        ▶
-  16                                        ▶
-  17   !   [Null Set(M1)] (identifier) [Node Set(M0)]  16
-  20   !   [Null Set(M0)] (number) [Node Set(M1)]  16
+  08   !   (function_declaration)           09
+  09   ▽   name: (identifier) [Node Set(M2)]  11
+  11   △   _                                12
+  12                                        ▶
+  13                                        ▶
+  14  ...  
+  15  ...  
+  16   !   [Null Set(M1)] (identifier) [Node Set(M0)]  13
+  19   !   [Null Set(M0)] (number) [Node Set(M1)]  13
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_single.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_single.snap
index e9e2c90..66a8892 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_single.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__definitions_single.snap
@@ -20,17 +20,15 @@ M0: S1 → T0  ; id: <Node>
 N0: S2 → T1  ; Foo
 
 [entrypoints]
-Foo = 06 :: T1
+Foo = 6 :: T1
 
 [transitions]
 _ObjWrap:
-  00   ε   [Obj]                            02
-  02       Trampoline                       03
-  03   ε   [EndObj]                         05
-  05                                        ▶
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
 
 Foo:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Node Set(M0)]      10
-  10                                        ▶
+  6   !   (identifier) [Node Set(M0)]       8
+  8                                         ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_alternation.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_alternation.snap
index 81b4aa8..c6c3dc9 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_alternation.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_alternation.snap
@@ -40,12 +40,12 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (call_expression)                08
-  08   ▽   function: _                      09
-  09   ε                                    12, 16
-  11                                        ▶
-  12   !   [Null Set(M1)] (identifier) [Node Set(M0)]  19
+  06   !   (call_expression)                08
+  07  ...  
+  08   ▽   function: _                      11, 16
+  10                                        ▶
+  11   !   [Null Set(M1)] (identifier) [Node Set(M0)]  19
+  14  ...  
   15  ...  
   16   !   [Null Set(M0)] (number) [Node Set(M1)]  19
-  19   △   _                                11
+  19   △   _                                10
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_multiple.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_multiple.snap
index 0f9ef7c..3438f84 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_multiple.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_multiple.snap
@@ -38,8 +38,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (binary_expression)              08
+  06   !   (binary_expression)              08
+  07  ...  
   08   ▽   left: (_) [Node Set(M0)]         10
   10   ▷   right: (_) [Node Set(M1)]        12
   12   △   _                                13
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_negated.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_negated.snap
index eae61e7..e5a502c 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_negated.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_negated.snap
@@ -32,9 +32,7 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   -value (pair)                    10
-  10   ▽   key: (property_identifier) [Node Set(M0)]  12
-  12   △   _                                13
-  13                                        ▶
+  06   !   -value (pair)                    08
+  08   ▽   key: (property_identifier) [Node Set(M0)]  10
+  10   △   _                                11
+  11                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_single.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_single.snap
index e58282c..cd2db34 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_single.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__fields_single.snap
@@ -31,8 +31,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (function_declaration)           08
+  06   !   (function_declaration)           08
+  07  ...  
   08   ▽   name: (identifier) [Node Set(M0)]  10
   10   △   _                                11
   11                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_anonymous.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_anonymous.snap
index 21a5d69..ffe2426 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_anonymous.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_anonymous.snap
@@ -31,8 +31,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (binary_expression)              08
+  06   !   (binary_expression)              08
+  07  ...  
   08   ▽   "+" [Node Set(M0)]               10
   10   △   _                                11
   11                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_error.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_error.snap
index f40606b..4a21410 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_error.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_error.snap
@@ -19,17 +19,15 @@ M0: S1 → T0  ; err: <Node>
 N0: S2 → T1  ; Test
 
 [entrypoints]
-Test = 06 :: T1
+Test = 6 :: T1
 
 [transitions]
 _ObjWrap:
-  00   ε   [Obj]                            02
-  02       Trampoline                       03
-  03   ε   [EndObj]                         05
-  05                                        ▶
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   (_) [Node Set(M0)]               10
-  10                                        ▶
+  6   !   (_) [Node Set(M0)]                8
+  8                                         ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_missing.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_missing.snap
index fb1d039..a93a359 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_missing.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_missing.snap
@@ -19,17 +19,15 @@ M0: S1 → T0  ; m: <Node>
 N0: S2 → T1  ; Test
 
 [entrypoints]
-Test = 06 :: T1
+Test = 6 :: T1
 
 [transitions]
 _ObjWrap:
-  00   ε   [Obj]                            02
-  02       Trampoline                       03
-  03   ε   [EndObj]                         05
-  05                                        ▶
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   (_) [Node Set(M0)]               10
-  10                                        ▶
+  6   !   (_) [Node Set(M0)]                8
+  8                                         ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_named.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_named.snap
index ef7b2bf..6ad1700 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_named.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_named.snap
@@ -20,17 +20,15 @@ M0: S1 → T0  ; id: <Node>
 N0: S2 → T1  ; Test
 
 [entrypoints]
-Test = 06 :: T1
+Test = 6 :: T1
 
 [transitions]
 _ObjWrap:
-  00   ε   [Obj]                            02
-  02       Trampoline                       03
-  03   ε   [EndObj]                         05
-  05                                        ▶
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Node Set(M0)]      10
-  10                                        ▶
+  6   !   (identifier) [Node Set(M0)]       8
+  8                                         ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_wildcard_any.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_wildcard_any.snap
index e53bbd4..4d0d45e 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_wildcard_any.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_wildcard_any.snap
@@ -30,8 +30,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (pair)                           08
+  06   !   (pair)                           08
+  07  ...  
   08   ▽   key: _ [Node Set(M0)]            10
   10   △   _                                11
   11                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_wildcard_named.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_wildcard_named.snap
index 1e706ce..be61600 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_wildcard_named.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__nodes_wildcard_named.snap
@@ -30,8 +30,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (pair)                           08
+  06   !   (pair)                           08
+  07  ...  
   08   ▽   key: (_) [Node Set(M0)]          10
   10   △   _                                11
   11                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_first_child.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_first_child.snap
index 75163df..61c2a5a 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_first_child.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_first_child.snap
@@ -39,19 +39,12 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (program)                        08
-  08   ε                                    28, 16
-  10                                        ▶
-  11   ▽   (number) [Node Set(M1)]          29
-  13   ▷   (number) [Node Set(M1)]          29
-  15  ...  
-  16   ε   [Null Set(M0)]                   11
-  18   !   (identifier) [Node Set(M0)]      13
-  20   ε   [Null Set(M0)]                   13
-  22   ▷   _                                26
-  23  ...  
-  24   ε                                    22, 20
-  26   ε                                    18, 24
-  28   ▽   _                                26
-  29   △   _                                10
+  06   !   (program)                        20, 09
+  08                                        ▶
+  09   ▽   [Null Set(M0)] (number) [Node Set(M1)]  22
+  12   ▷   (number) [Node Set(M1)]          22
+  14   !   (identifier) [Node Set(M0)]      12
+  16   ε   [Null Set(M0)]                   12
+  18   ▷   _                                14, 18, 16
+  20   ▽   _                                14, 18, 16
+  22   △   _                                08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_null_injection.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_null_injection.snap
index b10e4bb..1bd8169 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_null_injection.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__optional_null_injection.snap
@@ -32,16 +32,12 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (function_declaration)           08
-  08   ε                                    23, 11
-  10                                        ▶
-  11   ε   [Null Set(M0)]                   10
-  13   !   (decorator) [Node Set(M0)]       24
+  06   !   (function_declaration)           18, 09
+  08                                        ▶
+  09   ε   [Null Set(M0)]                   08
+  11   !   (decorator) [Node Set(M0)]       20
+  13   ε   [Null Set(M0)]                   20
   15  ...  
-  16   ε   [Null Set(M0)]                   24
-  18   ▷   _                                21
-  19   ε                                    18, 16
-  21   ε                                    13, 19
-  23   ▽   _                                21
-  24   △   _                                10
+  16   ▷   _                                11, 16, 13
+  18   ▽   _                                11, 16, 13
+  20   △   _                                08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_first_child_array.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_first_child_array.snap
index c36d438..2afc74f 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_first_child_array.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_first_child_array.snap
@@ -39,24 +39,18 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08   ε   [Arr]                            10
-  10   ε                                    31, 24
-  12   !   (identifier) [Node Push]         14
-  14   ε                                    37, 21
-  16                                        ▶
-  17   ▽   (number) [Node Set(M1)]          38
-  19   ▷   (number) [Node Set(M1)]          38
-  21   ε   [EndArr Set(M0)]                 19
-  23  ...  
-  24   ε   [EndArr Set(M0)]                 17
-  26   ▷   _                                29
-  27   ε                                    26, 21
-  29   ε                                    12, 27
-  31   ▽   _                                29
-  32   ▷   _                                35
-  33   ε                                    32, 21
-  35   ε                                    12, 33
-  37   ▷   _                                35
-  38   △   _                                16
+  06   !   (array)                          08
+  07  ...  
+  08   ε   [Arr]                            24, 19
+  10                                        ▶
+  11   ▽   [EndArr Set(M0)] (number) [Node Set(M1)]  30
+  14  ...  
+  15  ...  
+  16   ▷   [EndArr Set(M0)] (number) [Node Set(M1)]  30
+  19   ε                                    11
+  20   !   (identifier) [Node Push]         28, 16
+  22   ▷   _                                20, 22, 16
+  24   ▽   _                                20, 22, 16
+  26   ▷   _                                20, 26, 16
+  28   ▷   _                                20, 26, 16
+  30   △   _                                10
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_optional.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_optional.snap
index b10e4bb..1bd8169 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_optional.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_optional.snap
@@ -32,16 +32,12 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (function_declaration)           08
-  08   ε                                    23, 11
-  10                                        ▶
-  11   ε   [Null Set(M0)]                   10
-  13   !   (decorator) [Node Set(M0)]       24
+  06   !   (function_declaration)           18, 09
+  08                                        ▶
+  09   ε   [Null Set(M0)]                   08
+  11   !   (decorator) [Node Set(M0)]       20
+  13   ε   [Null Set(M0)]                   20
   15  ...  
-  16   ε   [Null Set(M0)]                   24
-  18   ▷   _                                21
-  19   ε                                    18, 16
-  21   ε                                    13, 19
-  23   ▽   _                                21
-  24   △   _                                10
+  16   ▷   _                                11, 16, 13
+  18   ▽   _                                11, 16, 13
+  20   △   _                                08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_optional_nongreedy.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_optional_nongreedy.snap
index 7fabbca..18033b7 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_optional_nongreedy.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_optional_nongreedy.snap
@@ -32,16 +32,12 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (function_declaration)           08
-  08   ε                                    11, 23
-  10                                        ▶
-  11   ε   [Null Set(M0)]                   10
-  13   !   (decorator) [Node Set(M0)]       24
+  06   !   (function_declaration)           09, 18
+  08                                        ▶
+  09   ε   [Null Set(M0)]                   08
+  11   !   (decorator) [Node Set(M0)]       20
+  13   ε   [Null Set(M0)]                   20
   15  ...  
-  16   ε   [Null Set(M0)]                   24
-  18   ▷   _                                21
-  19   ε                                    16, 18
-  21   ε                                    19, 13
-  23   ▽   _                                21
-  24   △   _                                10
+  16   ▷   _                                13, 16, 11
+  18   ▽   _                                13, 16, 11
+  20   △   _                                08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_plus.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_plus.snap
index 9475749..61290af 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_plus.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_plus.snap
@@ -31,17 +31,11 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε   [Arr]                            10
-  10   !   _                                19
-  11   !   (identifier) [Node Push]         13
-  13   ε                                    26, 16
-  15                                        ▶
-  16   ε   [EndArr Set(M0)]                 15
-  18   ▷   _                                19
-  19   ε                                    11, 18
-  21   ▷   _                                24
-  22   ε                                    21, 16
-  24   ε                                    11, 22
-  26   ▷   _                                24
+  06   !   [Arr] _                          11, 13
+  08                                        ▶
+  09   ε   [EndArr Set(M0)]                 08
+  11   !   (identifier) [Node Push]         18, 09
+  13   ▷   _                                11, 13
+  15  ...  
+  16   ▷   _                                11, 16, 09
+  18   ▷   _                                11, 16, 09
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_plus_nongreedy.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_plus_nongreedy.snap
index 789bbb0..2640d65 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_plus_nongreedy.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_plus_nongreedy.snap
@@ -31,17 +31,11 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε   [Arr]                            10
-  10   !   _                                19
-  11   !   (identifier) [Node Push]         13
-  13   ε                                    16, 26
-  15                                        ▶
-  16   ε   [EndArr Set(M0)]                 15
-  18   ▷   _                                19
-  19   ε                                    18, 11
-  21   ▷   _                                24
-  22   ε                                    16, 21
-  24   ε                                    22, 11
-  26   ▷   _                                24
+  06   !   [Arr] _                          13, 11
+  08                                        ▶
+  09   ε   [EndArr Set(M0)]                 08
+  11   !   (identifier) [Node Push]         09, 18
+  13   ▷   _                                13, 11
+  15  ...  
+  16   ▷   _                                09, 16, 11
+  18   ▷   _                                09, 16, 11
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_repeat_navigation.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_repeat_navigation.snap
index 3491b6c..210a72a 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_repeat_navigation.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_repeat_navigation.snap
@@ -32,22 +32,15 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (function_declaration)           08
-  08   ε   [Arr]                            10
-  10   ε                                    28, 21
-  12   ε   [EndArr Set(M0)]                 14
-  14   △   _                                20
+  06   !   (function_declaration)           08
+  07  ...  
+  08   ε   [Arr]                            18, 11
+  10                                        ▶
+  11   ε   [EndArr Set(M0)]                 10
+  13   !   (decorator) [Node Push]          22, 24
   15  ...  
-  16   !   (decorator) [Node Push]          18
-  18   ε                                    34, 12
-  20                                        ▶
-  21   ε   [EndArr Set(M0)]                 20
-  23   ▷   _                                26
-  24   ε                                    23, 12
-  26   ε                                    16, 24
-  28   ▽   _                                26
-  29   ▷   _                                32
-  30   ε                                    29, 12
-  32   ε                                    16, 30
-  34   ▷   _                                32
+  16   ▷   _                                13, 16, 24
+  18   ▽   _                                13, 16, 24
+  20   ▷   _                                13, 20, 24
+  22   ▷   _                                13, 20, 24
+  24   △   [EndArr Set(M0)] _               10
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_sequence_in_called_def.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_sequence_in_called_def.snap
index 67b14e6..7d03898 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_sequence_in_called_def.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_sequence_in_called_def.snap
@@ -34,9 +34,9 @@ N1: S5 → T4  ; Collect
 N2: S6 → T4  ; Test
 
 [entrypoints]
-Collect = 11 :: T4
+Collect = 09 :: T4
 Item    = 06 :: T1
-Test    = 16 :: T4
+Test    = 11 :: T4
 
 [transitions]
 _ObjWrap:
@@ -46,38 +46,27 @@ _ObjWrap:
   05                                        ▶
 
 Item:
-  06   ε                                    08
-  07  ...  
-  08   !   (identifier) [Node Set(M0)]      10
-  10                                        ▶
+  06   !   (identifier) [Node Set(M0)]      08
+  08                                        ▶
 
 Collect:
-  11   ε                                    12
-  12   ε   [Arr]                            14
-  14   ε                                    44, 27
+  09   ε   [Arr]                            32, 16
 
 Test:
-  16   ε                                    17
-  17   !   (array)                          18
-  18   ▽   (Collect)                        11 : 19
-  19   △   _                                20
-  20                                        ▶
-  21   ε   [EndObj Push]                    24
-  23  ...  
-  24   ε                                    50, 27
-  26                                        ▶
-  27   ε   [EndArr Set(M2)]                 26
-  29   ε   [Set(M1)]                        21
+  11   !   (array)                          12
+  12   ▽   (Collect)                        09 : 13
+  13   △   _                                14
+  14                                        ▶
+  15                                        ▶
+  16   ε   [EndArr Set(M2)]                 15
+  18   ε   [EndObj Push]                    36, 16
+  20   ε   [Set(M1)]                        18
+  22   ε   [EndObj]                         20
+  24   !   (Item)                           06 : 22
+  25   ε   [Obj]                            24
+  27   ε   [Obj]                            25
+  29   ▷   _                                27, 29, 16
   31  ...  
-  32   ε   [EndObj]                         29
-  34   !   (Item)                           06 : 32
-  35   ε   [Obj]                            34
-  37   ε   [Obj]                            35
-  39   ▷   _                                42
-  40   ε                                    39, 27
-  42   ε                                    37, 40
-  44   !   _                                42
-  45   ▷   _                                48
-  46   ε                                    45, 27
-  48   ε                                    37, 46
-  50   ▷   _                                48
+  32   !   _                                27, 29, 16
+  34   ▷   _                                27, 34, 16
+  36   ▷   _                                27, 34, 16
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_star.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_star.snap
index 7741aa4..1bdf2c4 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_star.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_star.snap
@@ -31,19 +31,12 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε   [Arr]                            10
-  10   ε                                    24, 17
-  12   !   (identifier) [Node Push]         14
-  14   ε                                    30, 17
-  16                                        ▶
-  17   ε   [EndArr Set(M0)]                 16
-  19   ▷   _                                22
-  20   ε                                    19, 17
-  22   ε                                    12, 20
-  24   !   _                                22
-  25   ▷   _                                28
-  26   ε                                    25, 17
-  28   ε                                    12, 26
-  30   ▷   _                                28
+  06   ε   [Arr]                            16, 09
+  08                                        ▶
+  09   ε   [EndArr Set(M0)]                 08
+  11   !   (identifier) [Node Push]         20, 09
+  13   ▷   _                                11, 13, 09
+  15  ...  
+  16   !   _                                11, 13, 09
+  18   ▷   _                                11, 18, 09
+  20   ▷   _                                11, 18, 09
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_star_nongreedy.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_star_nongreedy.snap
index 5bb48f2..135a352 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_star_nongreedy.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_star_nongreedy.snap
@@ -31,19 +31,12 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    08
-  07  ...  
-  08   ε   [Arr]                            10
-  10   ε                                    17, 24
-  12   !   (identifier) [Node Push]         14
-  14   ε                                    17, 30
-  16                                        ▶
-  17   ε   [EndArr Set(M0)]                 16
-  19   ▷   _                                22
-  20   ε                                    17, 19
-  22   ε                                    20, 12
-  24   !   _                                22
-  25   ▷   _                                28
-  26   ε                                    17, 25
-  28   ε                                    26, 12
-  30   ▷   _                                28
+  06   ε   [Arr]                            09, 16
+  08                                        ▶
+  09   ε   [EndArr Set(M0)]                 08
+  11   !   (identifier) [Node Push]         09, 20
+  13   ▷   _                                09, 13, 11
+  15  ...  
+  16   !   _                                09, 13, 11
+  18   ▷   _                                09, 18, 11
+  20   ▷   _                                09, 18, 11
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_struct_array.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_struct_array.snap
index 17bca10..72fbc9f 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_struct_array.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__quantifiers_struct_array.snap
@@ -42,27 +42,17 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08   ε   [Arr]                            10
-  10   ε                                    36, 21
-  12   ε   [EndArr Set(M2)]                 14
-  14   △   _                                20
-  15  ...  
-  16   ε   [EndObj Push]                    18
-  18   ε                                    42, 12
-  20                                        ▶
-  21   ε   [EndArr Set(M2)]                 20
-  23  ...  
-  24   ▷   (number) [Node Set(M1)]          16
-  26   !   (identifier) [Node Set(M0)]      24
-  28   ε   [Obj]                            26
-  30   ▷   _                                34
-  31  ...  
-  32   ε                                    30, 12
-  34   ε                                    28, 32
-  36   ▽   _                                34
-  37   ▷   _                                40
-  38   ε                                    37, 12
-  40   ε                                    28, 38
-  42   ▷   _                                40
+  06   !   (array)                          08
+  07  ...  
+  08   ε   [Arr]                            22, 12
+  10                                        ▶
+  11   ε                                    28
+  12   ε   [EndArr Set(M2)]                 10
+  14   ε   [EndObj Push]                    26, 11
+  16   ▷   (number) [Node Set(M1)]          14
+  18   !   [Obj] (identifier) [Node Set(M0)]  16
+  20   ▷   _                                18, 20, 28
+  22   ▽   _                                18, 20, 28
+  24   ▷   _                                18, 24, 28
+  26   ▷   _                                18, 24, 28
+  28   △   [EndArr Set(M2)] _               10
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__recursion_simple.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__recursion_simple.snap
index b5c56f3..404761e 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__recursion_simple.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__recursion_simple.snap
@@ -52,16 +52,11 @@ _ObjWrap:
   05                                        ▶
 
 Expr:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    16, 24
-  10   ε   [Set(M2)]                        12
-  12   △   _                                19
-  13                                        ▶
-  14  ...  
+  06   ε                                    12, 18
+  08   ▷   arguments: (Expr)                06 : 09
+  09   △   [Set(M2)] _ [EndEnum]            11
+  11                                        ▶
+  12   !   [Enum(M3)] (number) [Text Set(M0) EndEnum]  11
   15  ...  
-  16   !   [Enum(M3)] (number) [Text Set(M0) EndEnum]  13
-  19   ε   [EndEnum]                        13
-  21   ▷   arguments: (Expr)                06 : 10
-  22   ▽   function: (identifier) [Node Set(M1)]  21
-  24   !   [Enum(M4)] (call_expression)     22
+  16   ▽   function: (identifier) [Node Set(M1)]  08
+  18   !   [Enum(M4)] (call_expression)     16
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__recursion_with_structured_result.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__recursion_with_structured_result.snap
index d9f2576..b3ff45c 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__recursion_with_structured_result.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__recursion_with_structured_result.snap
@@ -51,7 +51,7 @@ N1: S08 → T05  ; Test
 
 [entrypoints]
 Expr = 06 :: T04
-Test = 10 :: T05
+Test = 08 :: T05
 
 [transitions]
 _ObjWrap:
@@ -61,22 +61,16 @@ _ObjWrap:
   05                                        ▶
 
 Expr:
-  06   ε                                    08
-  07  ...  
-  08   ε                                    21, 29
+  06   ε                                    17, 22
 
 Test:
-  10   ε                                    11
-  11   !   (program)                        12
-  12   ▽   (Expr)                           06 : 13
-  13   ε   [Set(M5)]                        15
-  15   △   _                                16
+  08   !   (program)                        09
+  09   ▽   (Expr)                           06 : 10
+  10   △   [Set(M5)] _                      12
+  12                                        ▶
+  13   ▷   arguments: (Expr)                06 : 14
+  14   △   [Set(M2)] _ [EndEnum]            16
   16                                        ▶
-  17   ε   [Set(M2)]                        19
-  19   △   _                                24
-  20                                        ▶
-  21   !   [Enum(M3)] (number) [Text Set(M0) EndEnum]  20
-  24   ε   [EndEnum]                        20
-  26   ▷   arguments: (Expr)                06 : 17
-  27   ▽   function: (identifier) [Node Set(M1)]  26
-  29   !   [Enum(M4)] (call_expression)     27
+  17   !   [Enum(M3)] (number) [Text Set(M0) EndEnum]  16
+  20   ▽   function: (identifier) [Node Set(M1)]  13
+  22   !   [Enum(M4)] (call_expression)     20
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_basic.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_basic.snap
index bed4323..e4cf951 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_basic.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_basic.snap
@@ -29,9 +29,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08   ▽   (identifier)                     09
-  09   ▷   (number)                         10
-  10   △   _                                11
-  11                                        ▶
+  06   !   (array)                          07
+  07   ▽   (identifier)                     08
+  08   ▷   (number)                         09
+  09   △   _                                10
+  10                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_in_quantifier.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_in_quantifier.snap
index d9ef2c8..eebd462 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_in_quantifier.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_in_quantifier.snap
@@ -33,24 +33,15 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08   ε   [Arr]                            10
-  10   ε                                    29, 21
-  12   ε   [EndArr Set(M0)]                 14
-  14   △   _                                20
-  15  ...  
-  16   ▷   (number) [Node Push]             18
-  18   ε                                    36, 12
-  20                                        ▶
-  21   ε   [EndArr Set(M0)]                 20
-  23   !   (identifier)                     16
-  24   ▷   _                                27
-  25   ε                                    24, 12
-  27   ε                                    23, 25
-  29   ▽   _                                27
-  30   ▷   _                                34
-  31  ...  
-  32   ε                                    30, 12
-  34   ε                                    23, 32
-  36   ▷   _                                34
+  06   !   (array)                          08
+  07  ...  
+  08   ε   [Arr]                            18, 11
+  10                                        ▶
+  11   ε   [EndArr Set(M0)]                 10
+  13   ▷   (number) [Node Push]             22, 24
+  15   !   (identifier)                     13
+  16   ▷   _                                15, 16, 24
+  18   ▽   _                                15, 16, 24
+  20   ▷   _                                15, 20, 24
+  22   ▷   _                                15, 20, 24
+  24   △   [EndArr Set(M0)] _               10
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_nested.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_nested.snap
index acafb0e..ad5300b 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_nested.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_nested.snap
@@ -31,11 +31,10 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
-  08   ▽   (identifier)                     09
-  09   ▷   (number)                         10
-  10   ▷   (string)                         11
-  11   ▷   (null)                           12
-  12   △   _                                13
-  13                                        ▶
+  06   !   (array)                          07
+  07   ▽   (identifier)                     08
+  08   ▷   (number)                         09
+  09   ▷   (string)                         10
+  10   ▷   (null)                           11
+  11   △   _                                12
+  12                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_with_captures.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_with_captures.snap
index d41634d..adaeee3 100644
--- a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_with_captures.snap
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__emit_tests__sequences_with_captures.snap
@@ -38,8 +38,8 @@ _ObjWrap:
   05                                        ▶
 
 Test:
-  06   ε                                    07
-  07   !   (array)                          08
+  06   !   (array)                          08
+  07  ...  
   08   ▽   (identifier) [Node Set(M0)]      10
   10   ▷   (number) [Node Set(M1)]          12
   12   △   _                                13
diff --git a/crates/plotnik-compiler/src/parser/lexer.rs b/crates/plotnik-compiler/src/parser/lexer.rs
index 97ba771..0a4a9c5 100644
--- a/crates/plotnik-compiler/src/parser/lexer.rs
+++ b/crates/plotnik-compiler/src/parser/lexer.rs
@@ -62,7 +62,12 @@ pub fn lex(source: &str) -> Vec<Token> {
                         split_regex_predicate(source, span, SyntaxKind::OpRegexMatch, &mut tokens);
                     }
                     SyntaxKind::RegexPredicateNoMatch => {
-                        split_regex_predicate(source, span, SyntaxKind::OpRegexNoMatch, &mut tokens);
+                        split_regex_predicate(
+                            source,
+                            span,
+                            SyntaxKind::OpRegexNoMatch,
+                            &mut tokens,
+                        );
                     }
                     _ => {
                         tokens.push(Token::new(kind, range_to_text_range(span)));
diff --git a/crates/plotnik-compiler/src/typegen/typescript/naming.rs b/crates/plotnik-compiler/src/typegen/typescript/naming.rs
index 254ffb1..db378a4 100644
--- a/crates/plotnik-compiler/src/typegen/typescript/naming.rs
+++ b/crates/plotnik-compiler/src/typegen/typescript/naming.rs
@@ -120,7 +120,10 @@ impl Emitter<'_> {
         self.unique_name(&base)
     }
 
-    pub(super) fn generate_fallback_name(&mut self, type_def: &plotnik_bytecode::TypeDef) -> String {
+    pub(super) fn generate_fallback_name(
+        &mut self,
+        type_def: &plotnik_bytecode::TypeDef,
+    ) -> String {
         let base = match type_def.classify() {
             TypeData::Composite {
                 kind: TypeKind::Struct,
diff --git a/crates/plotnik-lib/src/lib.rs b/crates/plotnik-lib/src/lib.rs
index d46e886..9d0e85b 100644
--- a/crates/plotnik-lib/src/lib.rs
+++ b/crates/plotnik-lib/src/lib.rs
@@ -20,8 +20,8 @@
 pub use plotnik_core::colors;
 
 // Re-export modules from plotnik-bytecode
-pub use plotnik_bytecode::type_system;
 pub use plotnik_bytecode as bytecode;
+pub use plotnik_bytecode::type_system;
 
 // Re-export modules from plotnik-compiler
 pub use plotnik_compiler::analyze;
@@ -47,7 +47,7 @@ pub use plotnik_compiler::{Query, QueryBuilder, SourceId, SourceMap};
 // Re-export VM types
 pub use plotnik_vm::{
     EffectLog, FuelLimits, Materializer, NodeHandle, PrintTracer, RuntimeEffect, RuntimeError,
-    Tracer, Value, ValueMaterializer, Verbosity, VM, debug_verify_type,
+    Tracer, VM, Value, ValueMaterializer, Verbosity, debug_verify_type,
 };
 
 /// Embed bytecode with 64-byte alignment (zero-copy loading).
diff --git a/crates/plotnik-vm/src/engine/verify.rs b/crates/plotnik-vm/src/engine/verify.rs
index 8ee9eec..10450fe 100644
--- a/crates/plotnik-vm/src/engine/verify.rs
+++ b/crates/plotnik-vm/src/engine/verify.rs
@@ -4,9 +4,9 @@
 //! Zero-cost in release builds.
 
 use plotnik_bytecode::{Module, TypeId};
-use plotnik_core::Colors;
 #[cfg(debug_assertions)]
 use plotnik_bytecode::{StringsView, TypeData, TypeKind, TypesView};
+use plotnik_core::Colors;
 
 use super::Value;
 
diff --git a/crates/plotnik-vm/src/engine/vm.rs b/crates/plotnik-vm/src/engine/vm.rs
index d826c21..322ab29 100644
--- a/crates/plotnik-vm/src/engine/vm.rs
+++ b/crates/plotnik-vm/src/engine/vm.rs
@@ -195,7 +195,12 @@ impl<'t> VM<'t> {
 
     /// Create a new VM for execution.
     #[deprecated(note = "Use VM::builder(source, tree).trivia_types(...).build() instead")]
-    pub fn new(source: &'t str, tree: &'t Tree, trivia_types: Vec<u16>, limits: FuelLimits) -> Self {
+    pub fn new(
+        source: &'t str,
+        tree: &'t Tree,
+        trivia_types: Vec<u16>,
+        limits: FuelLimits,
+    ) -> Self {
         Self::builder(source, tree)
             .trivia_types(trivia_types)
             .limits(limits)
@@ -360,8 +365,8 @@ impl<'t> VM<'t> {
             let dfa = plotnik_bytecode::deserialize_dfa(regex_bytes)
                 .expect("regex DFA deserialization failed");
 
-            use regex_automata::dfa::Automaton;
             use regex_automata::Input;
+            use regex_automata::dfa::Automaton;
             let input = Input::new(node_text);
             let matched = dfa.try_search_fwd(&input).ok().flatten().is_some();
 
diff --git a/docs/binary-format/01-overview.md b/docs/binary-format/01-overview.md
index d4e9b33..9b9be52 100644
--- a/docs/binary-format/01-overview.md
+++ b/docs/binary-format/01-overview.md
@@ -24,21 +24,21 @@
 
 Sections appear in fixed order, each starting on a 64-byte boundary:
 
-| #  | Section       | Record Size | Count Source          |
-| -- | ------------- | ----------- | --------------------- |
-| 0  | Header        | 64 bytes    | (fixed)               |
-| 1  | [StringBlob]  | 1           | `str_blob_size`       |
-| 2  | [RegexBlob]   | 1           | `regex_blob_size`     |
-| 3  | [StringTable] | 4           | `str_table_count + 1` |
-| 4  | [RegexTable]  | 8           | `regex_table_count + 1`     |
-| 5  | [NodeTypes]   | 4           | `node_types_count`    |
-| 6  | [NodeFields]  | 4           | `node_fields_count`   |
-| 7  | [Trivia]      | 2           | `trivia_count`        |
-| 8  | [TypeDefs]    | 4           | `type_defs_count`     |
-| 9  | [TypeMembers] | 4           | `type_members_count`  |
-| 10 | [TypeNames]   | 4           | `type_names_count`    |
-| 11 | [Entrypoints] | 8           | `entrypoints_count`   |
-| 12 | [Transitions] | 8           | `transitions_count`   |
+| #   | Section       | Record Size | Count Source            |
+| --- | ------------- | ----------- | ----------------------- |
+| 0   | Header        | 64 bytes    | (fixed)                 |
+| 1   | [StringBlob]  | 1           | `str_blob_size`         |
+| 2   | [RegexBlob]   | 1           | `regex_blob_size`       |
+| 3   | [StringTable] | 4           | `str_table_count + 1`   |
+| 4   | [RegexTable]  | 8           | `regex_table_count + 1` |
+| 5   | [NodeTypes]   | 4           | `node_types_count`      |
+| 6   | [NodeFields]  | 4           | `node_fields_count`     |
+| 7   | [Trivia]      | 2           | `trivia_count`          |
+| 8   | [TypeDefs]    | 4           | `type_defs_count`       |
+| 9   | [TypeMembers] | 4           | `type_members_count`    |
+| 10  | [TypeNames]   | 4           | `type_names_count`      |
+| 11  | [Entrypoints] | 8           | `entrypoints_count`     |
+| 12  | [Transitions] | 8           | `transitions_count`     |
 
 [StringBlob]: 02-strings.md
 [StringTable]: 02-strings.md
diff --git a/docs/binary-format/03-symbols.md b/docs/binary-format/03-symbols.md
index a3a0f11..b8715b9 100644
--- a/docs/binary-format/03-symbols.md
+++ b/docs/binary-format/03-symbols.md
@@ -33,6 +33,7 @@ struct RegexEntry {
 The final entry is a sentinel with `string_id = 0` and `offset = blob_size`.
 
 To retrieve regex `i`:
+
 1. `pattern_id = table[i].string_id` → look up in StringTable for display
 2. `start = table[i].offset`
 3. `end = table[i+1].offset`
diff --git a/docs/binary-format/04-types.md b/docs/binary-format/04-types.md
index a177d16..d08a820 100644
--- a/docs/binary-format/04-types.md
+++ b/docs/binary-format/04-types.md
@@ -8,17 +8,17 @@ Type system metadata for code generation and runtime validation. Describes the s
 
 **TypeKind (u8)**: Discriminator for TypeDef.
 
-| Value | Kind            | Description                    |
-| ----- | --------------- | ------------------------------ |
-| 0     | `Void`          | Unit type, captures nothing    |
-| 1     | `Node`          | AST node reference             |
-| 2     | `String`        | Source text                    |
-| 3     | `Optional`      | Wraps another type             |
-| 4     | `ArrayZeroOrMore` | Zero or more (T*)            |
-| 5     | `ArrayOneOrMore`  | One or more (T+)             |
-| 6     | `Struct`        | Record with named fields       |
-| 7     | `Enum`          | Discriminated union            |
-| 8     | `Alias`         | Named reference to another type |
+| Value | Kind              | Description                     |
+| ----- | ----------------- | ------------------------------- |
+| 0     | `Void`            | Unit type, captures nothing     |
+| 1     | `Node`            | AST node reference              |
+| 2     | `String`          | Source text                     |
+| 3     | `Optional`        | Wraps another type              |
+| 4     | `ArrayZeroOrMore` | Zero or more (T\*)              |
+| 5     | `ArrayOneOrMore`  | One or more (T+)                |
+| 6     | `Struct`          | Record with named fields        |
+| 7     | `Enum`            | Discriminated union             |
+| 8     | `Alias`           | Named reference to another type |
 
 ### Node Semantics
 
@@ -51,17 +51,17 @@ struct TypeDef {
 
 **Field semantics by kind**:
 
-| Kind              | `data`         | `count`        |
-| :---------------- | :------------- | :------------- |
-| `Void`            | 0              | 0              |
-| `Node`            | 0              | 0              |
-| `String`          | 0              | 0              |
-| `Optional`        | Inner TypeId   | 0              |
-| `ArrayZeroOrMore` | Inner TypeId   | 0              |
-| `ArrayOneOrMore`  | Inner TypeId   | 0              |
-| `Alias`           | Target TypeId  | 0              |
-| `Struct`          | MemberIndex    | FieldCount     |
-| `Enum`            | MemberIndex    | VariantCount   |
+| Kind              | `data`        | `count`      |
+| :---------------- | :------------ | :----------- |
+| `Void`            | 0             | 0            |
+| `Node`            | 0             | 0            |
+| `String`          | 0             | 0            |
+| `Optional`        | Inner TypeId  | 0            |
+| `ArrayZeroOrMore` | Inner TypeId  | 0            |
+| `ArrayOneOrMore`  | Inner TypeId  | 0            |
+| `Alias`           | Target TypeId | 0            |
+| `Struct`          | MemberIndex   | FieldCount   |
+| `Enum`            | MemberIndex   | VariantCount |
 
 > **Limit**: `count` is u8, so composites are limited to 255 members.
 
@@ -99,6 +99,7 @@ struct TypeName {
 Sorted lexicographically by name (resolved via String Table) for binary search.
 
 **Usage**:
+
 - Named definitions (`List = [...]`) get an entry
 - Custom type annotations (`@x :: Identifier`) create an Alias TypeDef with an entry
 - Anonymous types have no entry
@@ -126,6 +127,7 @@ N0: S2 → T1  ; Q
 ### Recursive Enum
 
 Query:
+
 ```
 List = [
     Nil: (nil)
diff --git a/docs/binary-format/06-transitions.md b/docs/binary-format/06-transitions.md
index ab405b5..5bb90d9 100644
--- a/docs/binary-format/06-transitions.md
+++ b/docs/binary-format/06-transitions.md
@@ -203,14 +203,14 @@ counts (u16)
 
 **Payload** (immediately follows header):
 
-| Order | Content          | Type                     | Condition         |
-| :---- | :--------------- | :----------------------- | :---------------- |
-| 1     | `pre_effects`    | `[EffectOp; pre_count]`  | always            |
-| 2     | `negated_fields` | `[u16; neg_count]`       | always            |
-| 3     | `post_effects`   | `[EffectOp; post_count]` | always            |
+| Order | Content          | Type                     | Condition          |
+| :---- | :--------------- | :----------------------- | :----------------- |
+| 1     | `pre_effects`    | `[EffectOp; pre_count]`  | always             |
+| 2     | `negated_fields` | `[u16; neg_count]`       | always             |
+| 3     | `post_effects`   | `[EffectOp; post_count]` | always             |
 | 4     | `predicate`      | `Predicate` (4 bytes)    | if `has_predicate` |
-| 5     | `successors`     | `[u16; succ_count]`      | always            |
-| 6     | Padding          | Zero bytes to step size  | always            |
+| 5     | `successors`     | `[u16; succ_count]`      | always             |
+| 6     | Padding          | Zero bytes to step size  | always             |
 
 **Predicate** (4 bytes, when `has_predicate` is set):
 
@@ -222,15 +222,15 @@ struct Predicate {
 }
 ```
 
-| Op | Name   | Meaning                          |
-| -- | ------ | -------------------------------- |
-| 1  | `==`   | Exact string match               |
-| 2  | `!=`   | Not equal                        |
-| 3  | `^=`   | Starts with                      |
-| 4  | `$=`   | Ends with                        |
-| 5  | `*=`   | Contains                         |
-| 6  | `=~`   | Regex match (value_ref = RegexId)|
-| 7  | `!~`   | Regex non-match                  |
+| Op  | Name | Meaning                           |
+| --- | ---- | --------------------------------- |
+| 1   | `==` | Exact string match                |
+| 2   | `!=` | Not equal                         |
+| 3   | `^=` | Starts with                       |
+| 4   | `$=` | Ends with                         |
+| 5   | `*=` | Contains                          |
+| 6   | `=~` | Regex match (value_ref = RegexId) |
+| 7   | `!~` | Regex non-match                   |
 
 **Payload Capacity**: