From 4a790407245560c8677f2439cfdc3c7bf074c4dd Mon Sep 17 00:00:00 2001
From: Sergei Zharinov <zharinov@users.noreply.github.com>
Date: Thu, 15 Jan 2026 17:24:40 -0300
Subject: [PATCH] perf: Pack successor instructions into cache-line gaps

---
 crates/plotnik-compiler/src/emit/layout.rs    | 326 +++++++++++++++---
 .../plotnik-compiler/src/emit/layout_tests.rs | 278 +++------------
 ...ternations_tagged_in_field_constraint.snap |   7 +-
 ..._emit__emit_tests__fields_alternation.snap |   7 +-
 ...__emit_tests__optional_null_injection.snap |   7 +-
 ..._tests__quantifiers_first_child_array.snap |  13 +-
 ...mit__emit_tests__quantifiers_optional.snap |   7 +-
 ...tests__quantifiers_optional_nongreedy.snap |   7 +-
 ..._compiler__emit__layout_tests__branch.snap |  44 +++
 ...it__layout_tests__cache_line_boundary.snap |  84 +++++
 ...iler__emit__layout_tests__call_return.snap |  51 +++
 ...emit__layout_tests__large_instruction.snap |  69 ++++
 ...ler__emit__layout_tests__linear_chain.snap |  46 +++
 ...mit__layout_tests__single_instruction.snap |  34 ++
 14 files changed, 682 insertions(+), 298 deletions(-)
 create mode 100644 crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__branch.snap
 create mode 100644 crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__cache_line_boundary.snap
 create mode 100644 crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__call_return.snap
 create mode 100644 crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__large_instruction.snap
 create mode 100644 crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__linear_chain.snap
 create mode 100644 crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__single_instruction.snap

diff --git a/crates/plotnik-compiler/src/emit/layout.rs b/crates/plotnik-compiler/src/emit/layout.rs
index bbbc833..a1105bc 100644
--- a/crates/plotnik-compiler/src/emit/layout.rs
+++ b/crates/plotnik-compiler/src/emit/layout.rs
@@ -1,7 +1,8 @@
 //! Cache-aligned instruction layout.
 //!
 //! Extracts linear chains from the control flow graph and places them
-//! contiguously. Pads instructions to prevent cache line straddling.
+//! contiguously. Packs successor instructions into free space of predecessor
+//! blocks for improved d-cache locality.
 
 use std::collections::{BTreeMap, HashSet};
 
@@ -10,6 +11,170 @@ use crate::bytecode::{InstructionIR, Label, LayoutResult};
 const CACHE_LINE: usize = 64;
 const STEP_SIZE: usize = 8;
 
+/// Intermediate representation for layout optimization.
+struct LayoutIR {
+    blocks: Vec<Block>,
+    label_to_block: BTreeMap<Label, usize>,
+    label_to_offset: BTreeMap<Label, u8>,
+}
+
+/// A 64-byte cache-line block.
+struct Block {
+    placements: Vec<Placement>,
+    used: u8,
+}
+
+/// An instruction placed within a block.
+struct Placement {
+    label: Label,
+    offset: u8,
+    size: u8,
+}
+
+impl Block {
+    fn new() -> Self {
+        Self {
+            placements: Vec::new(),
+            used: 0,
+        }
+    }
+
+    fn free(&self) -> u8 {
+        CACHE_LINE as u8 - self.used
+    }
+
+    fn can_fit(&self, size: u8) -> bool {
+        self.free() >= size
+    }
+
+    fn place(&mut self, label: Label, size: u8) -> u8 {
+        let offset = self.used;
+        self.placements.push(Placement {
+            label,
+            offset,
+            size,
+        });
+        self.used += size;
+        offset
+    }
+}
+
+impl LayoutIR {
+    fn new() -> Self {
+        Self {
+            blocks: Vec::new(),
+            label_to_block: BTreeMap::new(),
+            label_to_offset: BTreeMap::new(),
+        }
+    }
+
+    fn place(&mut self, label: Label, block_idx: usize, size: u8) {
+        let offset = self.blocks[block_idx].place(label, size);
+        self.label_to_block.insert(label, block_idx);
+        self.label_to_offset.insert(label, offset);
+    }
+
+    /// Move an instruction from its current block to a new block.
+    fn move_to(&mut self, label: Label, new_block_idx: usize, size: u8) {
+        // Remove from old block
+        if let Some(&old_block_idx) = self.label_to_block.get(&label)
+            && let block = &mut self.blocks[old_block_idx]
+            && let Some(pos) = block.placements.iter().position(|p| p.label == label)
+        {
+            let old_placement = block.placements.remove(pos);
+            block.used -= old_placement.size;
+
+            // Compact remaining placements
+            let mut offset = 0u8;
+            for p in &mut block.placements {
+                p.offset = offset;
+                offset += p.size;
+            }
+        }
+
+        // Add to new block
+        let offset = self.blocks[new_block_idx].place(label, size);
+        self.label_to_block.insert(label, new_block_idx);
+        self.label_to_offset.insert(label, offset);
+    }
+
+    fn finalize(self) -> LayoutResult {
+        let mut mapping = BTreeMap::new();
+        let mut max_step_end = 0u16;
+
+        for (block_idx, block) in self.blocks.iter().enumerate() {
+            let block_base_step = (block_idx * CACHE_LINE / STEP_SIZE) as u16;
+            for placement in &block.placements {
+                let step = block_base_step + (placement.offset / STEP_SIZE as u8) as u16;
+                mapping.insert(placement.label, step);
+                let step_end = step + (placement.size / STEP_SIZE as u8) as u16;
+                max_step_end = max_step_end.max(step_end);
+            }
+        }
+
+        LayoutResult::new(mapping, max_step_end)
+    }
+}
+
+/// Block-to-block reference counts for scoring.
+struct BlockRefs {
+    /// (from_block, to_block) -> reference count
+    direct: BTreeMap<(usize, usize), usize>,
+    /// block -> list of predecessor blocks
+    predecessors: BTreeMap<usize, Vec<usize>>,
+}
+
+impl BlockRefs {
+    fn new() -> Self {
+        Self {
+            direct: BTreeMap::new(),
+            predecessors: BTreeMap::new(),
+        }
+    }
+
+    fn add_ref(&mut self, from_block: usize, to_block: usize) {
+        *self.direct.entry((from_block, to_block)).or_default() += 1;
+        let preds = self.predecessors.entry(to_block).or_default();
+        if !preds.contains(&from_block) {
+            preds.push(from_block);
+        }
+    }
+
+    fn count(&self, from_block: usize, to_block: usize) -> usize {
+        self.direct.get(&(from_block, to_block)).copied().unwrap_or(0)
+    }
+
+    fn predecessors(&self, block: usize) -> &[usize] {
+        self.predecessors
+            .get(&block)
+            .map(|v| v.as_slice())
+            .unwrap_or(&[])
+    }
+}
+
+/// Score a candidate block for packing based on reference distance.
+/// Direct refs count 1.0, 1-hop = 0.5, 2-hop = 0.25, capped at 3 hops.
+fn block_score(target_block: usize, candidate_block: usize, refs: &BlockRefs) -> f32 {
+    let mut score = 0.0f32;
+    let mut frontier = vec![(candidate_block, 0u8)];
+    let mut visited = HashSet::new();
+
+    while let Some((block, dist)) = frontier.pop() {
+        if !visited.insert(block) || dist > 3 {
+            continue;
+        }
+
+        let direct_refs = refs.count(block, target_block);
+        score += direct_refs as f32 / (1u32 << dist) as f32;
+
+        for &pred in refs.predecessors(block) {
+            frontier.push((pred, dist + 1));
+        }
+    }
+
+    score
+}
+
 /// Successor graph for layout analysis.
 struct Graph {
     /// label -> list of successor labels
@@ -70,7 +235,121 @@ impl CacheAligned {
         let chains = extract_chains(&graph, instructions, entries);
         let ordered = order_chains(chains, entries);
 
-        assign_step_ids(ordered, &label_to_instr)
+        let mut ir = build_layout_ir(&ordered, &label_to_instr);
+        let refs = build_block_refs(&ir, &label_to_instr);
+        pack_successors(&mut ir, &refs, &label_to_instr);
+
+        ir.finalize()
+    }
+}
+
+/// Build initial LayoutIR from ordered chains.
+fn build_layout_ir(
+    chains: &[Vec<Label>],
+    label_to_instr: &BTreeMap<Label, &InstructionIR>,
+) -> LayoutIR {
+    let mut ir = LayoutIR::new();
+
+    for chain in chains {
+        for &label in chain {
+            let Some(instr) = label_to_instr.get(&label) else {
+                continue;
+            };
+            let size = instr.size() as u8;
+
+            // Ensure current block can fit, or create new one
+            if ir.blocks.is_empty() || !ir.blocks.last().unwrap().can_fit(size) {
+                ir.blocks.push(Block::new());
+            }
+            let block_idx = ir.blocks.len() - 1;
+
+            ir.place(label, block_idx, size);
+        }
+    }
+
+    ir
+}
+
+/// Build block reference counts from current layout.
+fn build_block_refs(
+    ir: &LayoutIR,
+    label_to_instr: &BTreeMap<Label, &InstructionIR>,
+) -> BlockRefs {
+    let mut refs = BlockRefs::new();
+
+    for (&label, &block_idx) in &ir.label_to_block {
+        let Some(instr) = label_to_instr.get(&label) else {
+            continue;
+        };
+        for succ in instr.successors() {
+            if let Some(&succ_block) = ir.label_to_block.get(&succ)
+                && succ_block != block_idx
+            {
+                refs.add_ref(block_idx, succ_block);
+            }
+        }
+    }
+
+    refs
+}
+
+/// Pack successor instructions into free space of predecessor blocks.
+///
+/// When X → Y and X is in block B, try to move Y to an earlier block
+/// that has free space and high reference score to B.
+fn pack_successors(
+    ir: &mut LayoutIR,
+    refs: &BlockRefs,
+    label_to_instr: &BTreeMap<Label, &InstructionIR>,
+) {
+    // Collect candidates: (successor_label, successor_block, predecessor_block)
+    // We want to move successors to earlier blocks with free space
+    let mut candidates: Vec<(Label, usize, usize)> = Vec::new();
+
+    for (&label, &block_idx) in &ir.label_to_block {
+        let Some(instr) = label_to_instr.get(&label) else {
+            continue;
+        };
+
+        // For each successor of this instruction
+        for succ in instr.successors() {
+            if let Some(&succ_block) = ir.label_to_block.get(&succ) {
+                // Only consider moving if successor is in a later block
+                if succ_block > block_idx {
+                    candidates.push((succ, succ_block, block_idx));
+                }
+            }
+        }
+    }
+
+    // Sort by successor block descending (process later blocks first)
+    candidates.sort_by_key(|(_, succ_block, _)| std::cmp::Reverse(*succ_block));
+
+    // Try to move each successor to an earlier block
+    for (succ_label, _succ_block, pred_block) in candidates {
+        // Re-check current block (might have changed)
+        let Some(&current_block) = ir.label_to_block.get(&succ_label) else {
+            continue;
+        };
+
+        let Some(instr) = label_to_instr.get(&succ_label) else {
+            continue;
+        };
+        let size = instr.size() as u8;
+
+        // Find the best earlier block with free space
+        // Prefer blocks that reference the predecessor block (cache locality)
+        let best = (0..current_block)
+            .filter(|&c| ir.blocks[c].can_fit(size))
+            .max_by(|&a, &b| {
+                let score_a = block_score(pred_block, a, refs);
+                let score_b = block_score(pred_block, b, refs);
+                score_a.partial_cmp(&score_b).unwrap_or(std::cmp::Ordering::Equal)
+            });
+
+        if let Some(candidate) = best {
+            ir.move_to(succ_label, candidate, size);
+        }
     }
 }
 
@@ -144,46 +423,3 @@ fn order_chains(mut chains: Vec<Vec<Label>>, entries: &[Label]) -> Vec<Vec<Label
     entry_chains
 }
 
-/// Assign step IDs with cache line awareness.
-fn assign_step_ids(
-    chains: Vec<Vec<Label>>,
-    label_to_instr: &BTreeMap<Label, &InstructionIR>,
-) -> LayoutResult {
-    let mut mapping = BTreeMap::new();
-
-    let mut current_step = 0u16;
-    let mut current_offset = 0usize; // Byte offset for cache alignment
-
-    for chain in chains {
-        for label in chain {
-            let Some(instr) = label_to_instr.get(&label) else {
-                continue;
-            };
-            let size = instr.size();
-
-            // Pad if instruction would straddle cache line boundary
-            let line_offset = current_offset % CACHE_LINE;
-            if line_offset + size > CACHE_LINE {
-                let padding_bytes = CACHE_LINE - line_offset;
-                let padding_steps = (padding_bytes / STEP_SIZE) as u16;
-                current_step += padding_steps;
-                current_offset += padding_bytes;
-            }
-
-            // Invariant: instruction must not straddle cache line
-            assert!(
-                current_offset % CACHE_LINE + size <= CACHE_LINE,
-                "instruction at offset {} with size {} straddles 64-byte cache line",
-                current_offset,
-                size
-            );
-
-            mapping.insert(label, current_step);
-            let step_count = (size / STEP_SIZE) as u16;
-            current_step += step_count;
-            current_offset += size;
-        }
-    }
-
-    LayoutResult::new(mapping, current_step)
-}
diff --git a/crates/plotnik-compiler/src/emit/layout_tests.rs b/crates/plotnik-compiler/src/emit/layout_tests.rs
index 7735010..d8ca17e 100644
--- a/crates/plotnik-compiler/src/emit/layout_tests.rs
+++ b/crates/plotnik-compiler/src/emit/layout_tests.rs
@@ -1,244 +1,72 @@
-use std::num::NonZeroU16;
-
-use super::layout::CacheAligned;
-use crate::bytecode::{CallIR, EffectIR, Label, MatchIR, NodeTypeIR, ReturnIR};
-use plotnik_bytecode::Nav;
-
-#[test]
-fn layout_empty() {
-    let result = CacheAligned::layout(&[], &[]);
-
-    assert_eq!(result.total_steps, 0);
-    assert!(result.label_to_step.is_empty());
+//! Layout snapshot tests.
+//!
+//! Tests verify cache-line aligned layout and gap-filling optimization.
+
+use crate::Query;
+use indoc::indoc;
+
+macro_rules! snap {
+    ($query:expr) => {{
+        let query = $query.trim();
+        let bytecode = Query::expect_valid_bytecode(query);
+        insta::with_settings!({
+            omit_expression => true
+        }, {
+            insta::assert_snapshot!(format!("{query}\n---\n{bytecode}"));
+        });
+    }};
 }
 
 #[test]
-fn layout_single_instruction() {
-    let instructions = vec![
-        MatchIR::terminal(Label(0))
-            .nav(Nav::Down)
-            .node_type(NodeTypeIR::Named(NonZeroU16::new(10)))
-            .into(),
-    ];
-
-    let result = CacheAligned::layout(&instructions, &[Label(0)]);
-
-    assert_eq!(result.label_to_step.get(&Label(0)), Some(&0u16));
-    assert_eq!(result.total_steps, 1);
+fn single_instruction() {
+    snap!(indoc! {r#"
+        Test = (identifier) @id
+    "#});
 }
 
 #[test]
-fn layout_linear_chain() {
-    // A -> B -> C -> ACCEPT
-    let instructions = vec![
-        MatchIR::at(Label(0))
-            .nav(Nav::Down)
-            .node_type(NodeTypeIR::Named(NonZeroU16::new(10)))
-            .next(Label(1))
-            .into(),
-        MatchIR::at(Label(1))
-            .nav(Nav::Next)
-            .node_type(NodeTypeIR::Named(NonZeroU16::new(20)))
-            .next(Label(2))
-            .into(),
-        MatchIR::terminal(Label(2)).nav(Nav::Up(1)).into(),
-    ];
-
-    let result = CacheAligned::layout(&instructions, &[Label(0)]);
-
-    // Should be contiguous: 0, 1, 2
-    assert_eq!(result.label_to_step.get(&Label(0)), Some(&0u16));
-    assert_eq!(result.label_to_step.get(&Label(1)), Some(&1u16));
-    assert_eq!(result.label_to_step.get(&Label(2)), Some(&2u16));
+fn linear_chain() {
+    snap!(indoc! {r#"
+        Test = (array (identifier) @a (number) @b)
+    "#});
 }
 
 #[test]
-fn layout_call_return() {
-    // Entry -> Call(target=2) -> Return
-    let instructions = vec![
-        MatchIR::at(Label(0))
-            .nav(Nav::Down)
-            .node_type(NodeTypeIR::Named(NonZeroU16::new(10)))
-            .next(Label(1))
-            .into(),
-        CallIR::new(Label(1), Label(2), Label(3))
-            .nav(Nav::Down)
-            .into(),
-        MatchIR::at(Label(2))
-            .nav(Nav::Down)
-            .node_type(NodeTypeIR::Named(NonZeroU16::new(20)))
-            .next(Label(4))
-            .into(),
-        MatchIR::terminal(Label(3)).nav(Nav::Up(1)).into(),
-        ReturnIR::new(Label(4)).into(),
-    ];
-
-    let result = CacheAligned::layout(&instructions, &[Label(0)]);
-
-    // All labels should have valid step IDs
-    assert!(result.label_to_step.contains_key(&Label(0)));
-    assert!(result.label_to_step.contains_key(&Label(1)));
-    assert!(result.label_to_step.contains_key(&Label(2)));
-    assert!(result.label_to_step.contains_key(&Label(3)));
-    assert!(result.label_to_step.contains_key(&Label(4)));
+fn branch() {
+    snap!(indoc! {r#"
+        Test = [(identifier) @id (number) @num]
+    "#});
 }
 
 #[test]
-fn layout_branch() {
-    // Entry -> [A, B] -> ACCEPT
-    let instructions = vec![
-        MatchIR::at(Label(0))
-            .next_many(vec![Label(1), Label(2)])
-            .into(),
-        MatchIR::terminal(Label(1))
-            .nav(Nav::Down)
-            .node_type(NodeTypeIR::Named(NonZeroU16::new(10)))
-            .into(),
-        MatchIR::terminal(Label(2))
-            .nav(Nav::Down)
-            .node_type(NodeTypeIR::Named(NonZeroU16::new(20)))
-            .into(),
-    ];
-
-    let result = CacheAligned::layout(&instructions, &[Label(0)]);
-
-    // All should have distinct step IDs
-    let step0 = result.label_to_step.get(&Label(0)).unwrap();
-    let step1 = result.label_to_step.get(&Label(1)).unwrap();
-    let step2 = result.label_to_step.get(&Label(2)).unwrap();
-
-    assert_ne!(step0, step1);
-    assert_ne!(step1, step2);
-    assert_ne!(step0, step2);
+fn call_return() {
+    snap!(indoc! {r#"
+        Inner = (identifier) @name
+        Test = (array (Inner) @item)
+    "#});
 }
 
 #[test]
-fn layout_match16_cache_alignment() {
-    // Match16 (16 bytes, 2 steps) at offset 56 would straddle (56+16=72 > 64)
-    // Place 7 Match8s (7 steps = 56 bytes) before Match16
-    // Expected: Match16 gets padded to step 8 (offset 64)
-    let mut instructions = Vec::new();
-
-    // 7 Match8 instructions in a chain: Label(0) -> Label(1) -> ... -> Label(6) -> Label(7)
-    for i in 0..7 {
-        instructions.push(
-            MatchIR::at(Label(i))
-                .nav(Nav::Down)
-                .next(Label(i + 1))
-                .into(),
-        );
-    }
-
-    // Match16 at Label(7): needs 2+ successors to become Match16
-    instructions.push(
-        MatchIR::at(Label(7))
-            .nav(Nav::Down)
-            .next_many(vec![Label(100), Label(101)])
-            .into(),
-    );
-
-    let result = CacheAligned::layout(&instructions, &[Label(0)]);
-
-    // Labels 0-6 should be at steps 0-6 (no padding needed)
-    for i in 0..7 {
-        assert_eq!(
-            result.label_to_step.get(&Label(i)),
-            Some(&(i as u16)),
-            "Label({i}) should be at step {i}"
-        );
-    }
-
-    // Label(7) would be at step 7 (offset 56) without padding
-    // But Match16 at offset 56 straddles (56+16=72 > 64), so it must be padded
-    // After padding: step 8 (offset 64)
-    let step7 = *result.label_to_step.get(&Label(7)).unwrap();
-    assert_eq!(step7, 8, "Match16 should be padded to step 8 (offset 64)");
-
-    // Total steps: 8 (padding at step 7) + 2 (Match16) = 10
-    assert_eq!(result.total_steps, 10);
-}
-
-#[test]
-fn layout_match8_no_padding_needed() {
-    // Match8 (8 bytes) never straddles: max offset 56, 56+8=64 <= 64
-    // Place 7 Match8s, then another Match8 - should NOT need padding
-    let mut instructions = Vec::new();
-
-    for i in 0..8 {
-        if i < 7 {
-            instructions.push(
-                MatchIR::at(Label(i))
-                    .nav(Nav::Down)
-                    .next(Label(i + 1))
-                    .into(),
-            );
-        } else {
-            instructions.push(MatchIR::terminal(Label(i)).nav(Nav::Down).into());
-        }
-    }
-
-    let result = CacheAligned::layout(&instructions, &[Label(0)]);
-
-    // All 8 Match8s should be contiguous: steps 0-7
-    for i in 0..8 {
-        assert_eq!(
-            result.label_to_step.get(&Label(i)),
-            Some(&(i as u16)),
-            "Label({i}) should be at step {i} (no padding)"
-        );
-    }
-
-    // Total steps: 8 (no padding)
-    assert_eq!(result.total_steps, 8);
+fn cache_line_boundary() {
+    // Many small instructions followed by larger one
+    snap!(indoc! {r#"
+        Test = (array
+            (identifier) @a
+            (identifier) @b
+            (identifier) @c
+            (identifier) @d
+            (identifier) @e
+            [(number) @x (string) @y]
+        )
+    "#});
 }
 
 #[test]
-fn layout_match32_cache_alignment() {
-    // Match32 (32 bytes, 4 steps) at offset 40 would straddle (40+32=72 > 64)
-    // Place 5 Match8s (5 steps = 40 bytes) before Match32
-    // Expected: Match32 gets padded to step 8 (offset 64)
-    let mut instructions: Vec<crate::bytecode::InstructionIR> = Vec::new();
-
-    // 5 Match8 instructions: Label(0) -> ... -> Label(4) -> Label(5)
-    for i in 0..5 {
-        instructions.push(
-            MatchIR::at(Label(i))
-                .nav(Nav::Down)
-                .next(Label(i + 1))
-                .into(),
-        );
-    }
-
-    // Match32 at Label(5): needs enough payload to become Match32 (9-12 slots)
-    // 3 pre + 3 post + 4 successors = 10 slots -> Match32
-    instructions.push(
-        MatchIR::at(Label(5))
-            .nav(Nav::Down)
-            .pre_effect(EffectIR::start_obj())
-            .pre_effect(EffectIR::start_obj())
-            .pre_effect(EffectIR::start_obj())
-            .post_effect(EffectIR::end_obj())
-            .post_effect(EffectIR::end_obj())
-            .post_effect(EffectIR::end_obj())
-            .next_many(vec![Label(100), Label(101), Label(102), Label(103)])
-            .into(),
-    );
-
-    // Verify it's Match32 (32 bytes)
-    assert_eq!(instructions.last().unwrap().size(), 32);
-
-    let result = CacheAligned::layout(&instructions, &[Label(0)]);
-
-    // Labels 0-4 at steps 0-4
-    for i in 0..5 {
-        assert_eq!(result.label_to_step.get(&Label(i)), Some(&(i as u16)));
-    }
-
-    // Label(5) would be at step 5 (offset 40) without padding
-    // Match32 at offset 40 straddles (40+32=72 > 64), so padded to step 8
-    let step5 = *result.label_to_step.get(&Label(5)).unwrap();
-    assert_eq!(step5, 8, "Match32 should be padded to step 8 (offset 64)");
-
-    // Total steps: 8 (3 padding steps at 5,6,7) + 4 (Match32) = 12
-    assert_eq!(result.total_steps, 12);
+fn large_instruction() {
+    // Instruction with many effects/successors
+    snap!(indoc! {r#"
+        Test = (object
+            {(pair) @a (pair) @b (pair) @c (pair) @d}* @items
+        )
+    "#});
 }
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 f3f45e2..2133085 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
@@ -43,9 +43,8 @@ _ObjWrap:
 
 Test:
   06   !   (pair)                           08
-  07  ...  
+  07   △   _                                10
   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
+  11   !   [Enum(M1)] (identifier) [Node Set(M0) EndEnum Set(M3)]  07
+  14   !   [Enum(M2)] (number) [EndEnum Set(M3)]  07
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 c6c3dc9..898cef0 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
@@ -44,8 +44,7 @@ Test:
   07  ...  
   08   ▽   function: _                      11, 16
   10                                        ▶
-  11   !   [Null Set(M1)] (identifier) [Node Set(M0)]  19
-  14  ...  
+  11   !   [Null Set(M1)] (identifier) [Node Set(M0)]  14
+  14   △   _                                10
   15  ...  
-  16   !   [Null Set(M0)] (number) [Node Set(M1)]  19
-  19   △   _                                10
+  16   !   [Null Set(M0)] (number) [Node Set(M1)]  14
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 1bd8169..664e920 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
@@ -35,9 +35,8 @@ Test:
   06   !   (function_declaration)           18, 09
   08                                        ▶
   09   ε   [Null Set(M0)]                   08
-  11   !   (decorator) [Node Set(M0)]       20
-  13   ε   [Null Set(M0)]                   20
-  15  ...  
+  11   !   (decorator) [Node Set(M0)]       15
+  13   ε   [Null Set(M0)]                   15
+  15   △   _                                08
   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 2afc74f..3709026 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
@@ -40,17 +40,14 @@ _ObjWrap:
 
 Test:
   06   !   (array)                          08
-  07  ...  
+  07   △   _                                10
   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
+  11   ▽   [EndArr Set(M0)] (number) [Node Set(M1)]  07
+  14   ▷   _                                20, 26, 16
+  16   ▷   [EndArr Set(M0)] (number) [Node Set(M1)]  07
   19   ε                                    11
-  20   !   (identifier) [Node Push]         28, 16
+  20   !   (identifier) [Node Push]         14, 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 1bd8169..664e920 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
@@ -35,9 +35,8 @@ Test:
   06   !   (function_declaration)           18, 09
   08                                        ▶
   09   ε   [Null Set(M0)]                   08
-  11   !   (decorator) [Node Set(M0)]       20
-  13   ε   [Null Set(M0)]                   20
-  15  ...  
+  11   !   (decorator) [Node Set(M0)]       15
+  13   ε   [Null Set(M0)]                   15
+  15   △   _                                08
   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 18033b7..036791f 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
@@ -35,9 +35,8 @@ Test:
   06   !   (function_declaration)           09, 18
   08                                        ▶
   09   ε   [Null Set(M0)]                   08
-  11   !   (decorator) [Node Set(M0)]       20
-  13   ε   [Null Set(M0)]                   20
-  15  ...  
+  11   !   (decorator) [Node Set(M0)]       15
+  13   ε   [Null Set(M0)]                   15
+  15   △   _                                08
   16   ▷   _                                13, 16, 11
   18   ▽   _                                13, 16, 11
-  20   △   _                                08
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__branch.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__branch.snap
new file mode 100644
index 0000000..c96111a
--- /dev/null
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__branch.snap
@@ -0,0 +1,44 @@
+---
+source: crates/plotnik-compiler/src/emit/layout_tests.rs
+---
+Test = [(identifier) @id (number) @num]
+---
+[strings]
+S0 "Beauty will save the world"
+S1 "id"
+S2 "num"
+S3 "Test"
+S4 "identifier"
+S5 "number"
+
+[type_defs]
+T0 = <Node>
+T1 = Struct  M0:2  ; { id, num }
+T2 = Struct  M2:1  ; { id }
+T3 = Struct  M3:1  ; { num }
+T4 = Optional(T0)  ; <Node>?
+
+[type_members]
+M0: S1 → T4  ; id: T4
+M1: S2 → T4  ; num: T4
+M2: S1 → T0  ; id: <Node>
+M3: S2 → T0  ; num: <Node>
+
+[type_names]
+N0: S3 → T1  ; Test
+
+[entrypoints]
+Test = 06 :: T1
+
+[transitions]
+_ObjWrap:
+  00   ε   [Obj]                            02
+  02       Trampoline                       03
+  03   ε   [EndObj]                         05
+  05                                        ▶
+
+Test:
+  06   ε                                    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__layout_tests__cache_line_boundary.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__cache_line_boundary.snap
new file mode 100644
index 0000000..caf0562
--- /dev/null
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__cache_line_boundary.snap
@@ -0,0 +1,84 @@
+---
+source: crates/plotnik-compiler/src/emit/layout_tests.rs
+---
+Test = (array
+    (identifier) @a
+    (identifier) @b
+    (identifier) @c
+    (identifier) @d
+    (identifier) @e
+    [(number) @x (string) @y]
+)
+---
+[strings]
+S00 "Beauty will save the world"
+S01 "a"
+S02 "b"
+S03 "c"
+S04 "d"
+S05 "e"
+S06 "x"
+S07 "y"
+S08 "Test"
+S09 "array"
+S10 "identifier"
+S11 "number"
+S12 "string"
+
+[type_defs]
+T00 = <Node>
+T01 = Struct  M00:7  ; { a, b, c, d, e, x, y }
+T02 = Struct  M07:1  ; { a }
+T03 = Struct  M08:1  ; { b }
+T04 = Struct  M09:1  ; { c }
+T05 = Struct  M10:1  ; { d }
+T06 = Struct  M11:1  ; { e }
+T07 = Struct  M12:1  ; { x }
+T08 = Struct  M13:1  ; { y }
+T09 = Struct  M14:2  ; { x, y }
+T10 = Optional(T00)  ; <Node>?
+
+[type_members]
+M00: S01 → T00  ; a: <Node>
+M01: S02 → T00  ; b: <Node>
+M02: S03 → T00  ; c: <Node>
+M03: S04 → T00  ; d: <Node>
+M04: S05 → T00  ; e: <Node>
+M05: S06 → T10  ; x: T10
+M06: S07 → T10  ; y: T10
+M07: S01 → T00  ; a: <Node>
+M08: S02 → T00  ; b: <Node>
+M09: S03 → T00  ; c: <Node>
+M10: S04 → T00  ; d: <Node>
+M11: S05 → T00  ; e: <Node>
+M12: S06 → T00  ; x: <Node>
+M13: S07 → T00  ; y: <Node>
+M14: S06 → T10  ; x: T10
+M15: S07 → T10  ; y: T10
+
+[type_names]
+N0: S08 → T01  ; Test
+
+[entrypoints]
+Test = 06 :: T01
+
+[transitions]
+_ObjWrap:
+  00   ε   [Obj]                            02
+  02       Trampoline                       03
+  03   ε   [EndObj]                         05
+  05                                        ▶
+
+Test:
+  06   !   (array)                          08
+  07  ...  
+  08   ▽   (identifier) [Node Set(M0)]      10
+  10   ▷   (identifier) [Node Set(M1)]      12
+  12   ▷   (identifier) [Node Set(M2)]      14
+  14   ▷   (identifier) [Node Set(M3)]      16
+  16   ▷   (identifier) [Node Set(M4)]      19, 24
+  18                                        ▶
+  19 !!▷   [Null Set(M15)] (number) [Node Set(M5)]  22
+  22   △   _                                18
+  23  ...  
+  24 !!▷   [Null Set(M14)] (string) [Node Set(M6)]  22
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__call_return.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__call_return.snap
new file mode 100644
index 0000000..ff4f7f3
--- /dev/null
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__call_return.snap
@@ -0,0 +1,51 @@
+---
+source: crates/plotnik-compiler/src/emit/layout_tests.rs
+---
+Inner = (identifier) @name
+Test = (array (Inner) @item)
+---
+[strings]
+S0 "Beauty will save the world"
+S1 "name"
+S2 "item"
+S3 "Inner"
+S4 "Test"
+S5 "identifier"
+S6 "array"
+
+[type_defs]
+T0 = <Node>
+T1 = Struct  M0:1  ; { name }
+T2 = Struct  M1:1  ; { item }
+
+[type_members]
+M0: S1 → T0  ; name: <Node>
+M1: S2 → T1  ; item: Inner
+
+[type_names]
+N0: S3 → T1  ; Inner
+N1: S4 → T2  ; Test
+
+[entrypoints]
+Inner = 06 :: T1
+Test  = 09 :: T2
+
+[transitions]
+_ObjWrap:
+  00   ε   [Obj]                            02
+  02       Trampoline                       03
+  03   ε   [EndObj]                         05
+  05                                        ▶
+
+Inner:
+  06   !   (identifier) [Node Set(M0)]      08
+  08                                        ▶
+
+Test:
+  09   !   (array) [Obj]                    11
+  11   ▽   (Inner)                          06 : 12
+  12   ε   [EndObj]                         14
+  14   ε                                    16
+  15  ...  
+  16   △   [Set(M1)] _                      18
+  18                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__large_instruction.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__large_instruction.snap
new file mode 100644
index 0000000..5014fa4
--- /dev/null
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__large_instruction.snap
@@ -0,0 +1,69 @@
+---
+source: crates/plotnik-compiler/src/emit/layout_tests.rs
+---
+Test = (object
+    {(pair) @a (pair) @b (pair) @c (pair) @d}* @items
+)
+---
+[strings]
+S0 "Beauty will save the world"
+S1 "a"
+S2 "b"
+S3 "c"
+S4 "d"
+S5 "items"
+S6 "Test"
+S7 "object"
+S8 "pair"
+
+[type_defs]
+T00 = <Node>
+T01 = Struct  M0:4  ; { a, b, c, d }
+T02 = ArrayStar(T01)  ; T01*
+T03 = Struct  M4:1  ; { items }
+T04 = Struct  M5:1  ; { a }
+T05 = Struct  M6:1  ; { b }
+T06 = Struct  M7:1  ; { c }
+T07 = Struct  M8:1  ; { d }
+
+[type_members]
+M0: S1 → T00  ; a: <Node>
+M1: S2 → T00  ; b: <Node>
+M2: S3 → T00  ; c: <Node>
+M3: S4 → T00  ; d: <Node>
+M4: S5 → T02  ; items: T02
+M5: S1 → T00  ; a: <Node>
+M6: S2 → T00  ; b: <Node>
+M7: S3 → T00  ; c: <Node>
+M8: S4 → T00  ; d: <Node>
+
+[type_names]
+N0: S6 → T03  ; Test
+
+[entrypoints]
+Test = 06 :: T03
+
+[transitions]
+_ObjWrap:
+  00   ε   [Obj]                            02
+  02       Trampoline                       03
+  03   ε   [EndObj]                         05
+  05                                        ▶
+
+Test:
+  06   !   (object)                         08
+  07  ...  
+  08   ε   [Arr]                            26, 12
+  10                                        ▶
+  11   ε                                    32
+  12   ε   [EndArr Set(M4)]                 10
+  14   ε   [EndObj Push]                    30, 11
+  16   ▷   (pair) [Node Set(M3)]            14
+  18   ▷   (pair) [Node Set(M2)]            16
+  20   ▷   (pair) [Node Set(M1)]            18
+  22   !   [Obj] (pair) [Node Set(M0)]      20
+  24   ▷   _                                22, 24, 32
+  26   ▽   _                                22, 24, 32
+  28   ▷   _                                22, 28, 32
+  30   ▷   _                                22, 28, 32
+  32   △   [EndArr Set(M4)] _               10
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__linear_chain.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__linear_chain.snap
new file mode 100644
index 0000000..aeecc65
--- /dev/null
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__linear_chain.snap
@@ -0,0 +1,46 @@
+---
+source: crates/plotnik-compiler/src/emit/layout_tests.rs
+---
+Test = (array (identifier) @a (number) @b)
+---
+[strings]
+S0 "Beauty will save the world"
+S1 "a"
+S2 "b"
+S3 "Test"
+S4 "array"
+S5 "identifier"
+S6 "number"
+
+[type_defs]
+T0 = <Node>
+T1 = Struct  M0:2  ; { a, b }
+T2 = Struct  M2:1  ; { a }
+T3 = Struct  M3:1  ; { b }
+
+[type_members]
+M0: S1 → T0  ; a: <Node>
+M1: S2 → T0  ; b: <Node>
+M2: S1 → T0  ; a: <Node>
+M3: S2 → T0  ; b: <Node>
+
+[type_names]
+N0: S3 → T1  ; Test
+
+[entrypoints]
+Test = 06 :: T1
+
+[transitions]
+_ObjWrap:
+  00   ε   [Obj]                            02
+  02       Trampoline                       03
+  03   ε   [EndObj]                         05
+  05                                        ▶
+
+Test:
+  06   !   (array)                          08
+  07  ...  
+  08   ▽   (identifier) [Node Set(M0)]      10
+  10   ▷   (number) [Node Set(M1)]          12
+  12   △   _                                13
+  13                                        ▶
diff --git a/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__single_instruction.snap b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__single_instruction.snap
new file mode 100644
index 0000000..22546b0
--- /dev/null
+++ b/crates/plotnik-compiler/src/emit/snapshots/plotnik_compiler__emit__layout_tests__single_instruction.snap
@@ -0,0 +1,34 @@
+---
+source: crates/plotnik-compiler/src/emit/layout_tests.rs
+---
+Test = (identifier) @id
+---
+[strings]
+S0 "Beauty will save the world"
+S1 "id"
+S2 "Test"
+S3 "identifier"
+
+[type_defs]
+T0 = <Node>
+T1 = Struct  M0:1  ; { id }
+
+[type_members]
+M0: S1 → T0  ; id: <Node>
+
+[type_names]
+N0: S2 → T1  ; Test
+
+[entrypoints]
+Test = 6 :: T1
+
+[transitions]
+_ObjWrap:
+  0   ε   [Obj]                             2
+  2       Trampoline                        3
+  3   ε   [EndObj]                          5
+  5                                         ▶
+
+Test:
+  6   !   (identifier) [Node Set(M0)]       8
+  8                                         ▶