diff --git a/crates/plotnik-compiler/src/bytecode/ir.rs b/crates/plotnik-compiler/src/bytecode/ir.rs
index 8eed365..15224c6 100644
--- a/crates/plotnik-compiler/src/bytecode/ir.rs
+++ b/crates/plotnik-compiler/src/bytecode/ir.rs
@@ -606,11 +606,20 @@ impl MatchIR {
             // counts layout: pre(3) | neg(3) | post(3) | succ(5) | has_pred(1) | reserved(1)
             assert!(
                 pre_count <= 7,
-                "pre_effects overflow: {pre_count} > 7 (use emit_match_with_cascade)"
+                "pre_effects overflow: {pre_count} > 7 (lowering should have cascaded)"
+            );
+            assert!(
+                neg_count <= 7,
+                "neg_fields overflow: {neg_count} > 7 (lowering should have cascaded)"
+            );
+            assert!(
+                post_count <= 7,
+                "post_effects overflow: {post_count} > 7 (lowering should have cascaded)"
+            );
+            assert!(
+                succ_count <= 31,
+                "successors overflow: {succ_count} > 31 (lowering should have cascaded)"
             );
-            assert!(neg_count <= 7, "neg_fields overflow: {neg_count} > 7");
-            assert!(post_count <= 7, "post_effects overflow: {post_count} > 7");
-            assert!(succ_count <= 31, "successors overflow: {succ_count} > 31");
 
             let counts = ((pre_count as u16) << 13)
                 | ((neg_count as u16) << 10)
diff --git a/crates/plotnik-compiler/src/compile/compiler.rs b/crates/plotnik-compiler/src/compile/compiler.rs
index 6f0e95e..5de4be3 100644
--- a/crates/plotnik-compiler/src/compile/compiler.rs
+++ b/crates/plotnik-compiler/src/compile/compiler.rs
@@ -15,6 +15,7 @@ use plotnik_bytecode::Nav;
 use super::capture::CaptureEffects;
 use super::dce::remove_unreachable;
 use super::epsilon_elim::eliminate_epsilons;
+use super::lower::lower;
 use super::error::{CompileError, CompileResult};
 use super::scope::StructScope;
 use super::verify::debug_verify_ir_fingerprint;
@@ -86,6 +87,9 @@ impl<'a> Compiler<'a> {
         // Remove unreachable instructions (bypassed epsilons, etc.)
         remove_unreachable(&mut result);
 
+        // Lower to bytecode-compatible form (cascade overflows)
+        lower(&mut result);
+
         Ok(result)
     }
 
diff --git a/crates/plotnik-compiler/src/compile/expressions.rs b/crates/plotnik-compiler/src/compile/expressions.rs
index 1dc74c3..e05bf97 100644
--- a/crates/plotnik-compiler/src/compile/expressions.rs
+++ b/crates/plotnik-compiler/src/compile/expressions.rs
@@ -49,7 +49,7 @@ impl Compiler<'_> {
             if let Some(p) = predicate {
                 m = m.predicate(p);
             }
-            return self.emit_match_with_cascade(m);
+            return self.emit_match(m);
         }
 
         // Determine Up navigation based on trailing anchor
@@ -123,7 +123,7 @@ impl Compiler<'_> {
         if let Some(p) = predicate {
             entry_match = entry_match.predicate(p);
         }
-        self.emit_match_with_cascade(entry_match);
+        self.emit_match(entry_match);
 
         entry
     }
@@ -201,7 +201,7 @@ impl Compiler<'_> {
         if let Some(p) = predicate {
             entry_match = entry_match.predicate(p);
         }
-        self.emit_match_with_cascade(entry_match);
+        self.emit_match(entry_match);
 
         entry
     }
@@ -236,7 +236,7 @@ impl Compiler<'_> {
             None => NodeTypeIR::Any, // `_` wildcard matches any node
         };
 
-        self.emit_match_with_cascade(
+        self.emit_match(
             MatchIR::epsilon(entry, exit)
                 .nav(nav)
                 .node_type(node_type)
diff --git a/crates/plotnik-compiler/src/compile/lower.rs b/crates/plotnik-compiler/src/compile/lower.rs
new file mode 100644
index 0000000..65dec7b
--- /dev/null
+++ b/crates/plotnik-compiler/src/compile/lower.rs
@@ -0,0 +1,206 @@
+//! Lowering pass: transforms unconstrained IR into bytecode-compatible form.
+//!
+//! This pass handles bytecode encoding constraints by splitting oversized
+//! instructions into cascading epsilon chains:
+//! - pre_effects > 7 → epsilon chain before match
+//! - post_effects > 7 → epsilon chain after match
+//! - neg_fields > 7 → epsilon chain for overflow checks
+//! - successors > 28 → cascading epsilon branches
+
+use plotnik_bytecode::{MAX_MATCH_PAYLOAD_SLOTS, MAX_PRE_EFFECTS};
+
+use crate::bytecode::{EffectIR, InstructionIR, Label, MatchIR};
+use crate::compile::CompileResult;
+
+const MAX_POST_EFFECTS: usize = 7;
+const MAX_NEG_FIELDS: usize = 7;
+
+enum PostChain {
+    NegFields(Vec<u16>),
+    PostEffects(Vec<EffectIR>),
+    Successors(Vec<Label>),
+}
+
+/// Lower IR to bytecode-compatible form.
+///
+/// Transforms instructions that exceed bytecode encoding limits into
+/// equivalent cascades of smaller instructions.
+pub fn lower(result: &mut CompileResult) {
+    let mut next_label = result
+        .instructions
+        .iter()
+        .map(|i| i.label().0)
+        .max()
+        .unwrap_or(0)
+        + 1;
+
+    let mut new_instructions = Vec::with_capacity(result.instructions.len());
+
+    for instr in result.instructions.drain(..) {
+        let InstructionIR::Match(m) = instr else {
+            new_instructions.push(instr);
+            continue;
+        };
+        lower_match(m, &mut new_instructions, &mut next_label);
+    }
+
+    result.instructions = new_instructions;
+}
+
+fn fresh_label(next: &mut u32) -> Label {
+    let l = Label(*next);
+    *next += 1;
+    l
+}
+
+fn lower_match(mut m: MatchIR, out: &mut Vec<InstructionIR>, next_label: &mut u32) {
+    // Step 1: Handle pre_effects overflow → epsilon chain before the match
+    if m.pre_effects.len() > MAX_PRE_EFFECTS {
+        let all_pre = std::mem::take(&mut m.pre_effects);
+        let entry = m.label;
+        m.label = fresh_label(next_label);
+        emit_effects_chain(entry, m.label, all_pre, out, next_label);
+    }
+
+    // Collect overflow chains to emit after the match
+    let mut post_chains: Vec<PostChain> = Vec::new();
+
+    if m.neg_fields.len() > MAX_NEG_FIELDS {
+        let overflow: Vec<_> = m.neg_fields.drain(MAX_NEG_FIELDS..).collect();
+        post_chains.push(PostChain::NegFields(overflow));
+    }
+
+    if m.post_effects.len() > MAX_POST_EFFECTS {
+        let overflow: Vec<_> = m.post_effects.drain(MAX_POST_EFFECTS..).collect();
+        post_chains.push(PostChain::PostEffects(overflow));
+    }
+
+    if m.successors.len() > MAX_MATCH_PAYLOAD_SLOTS {
+        let overflow: Vec<_> = m.successors.drain(MAX_MATCH_PAYLOAD_SLOTS - 1..).collect();
+        post_chains.push(PostChain::Successors(overflow));
+    }
+
+    if post_chains.is_empty() {
+        out.push(m.into());
+        return;
+    }
+
+    // Build chain: match → chain1 → chain2 → ... → final_succs
+    let mut current_succs = std::mem::take(&mut m.successors);
+
+    for chain in post_chains.into_iter().rev() {
+        let chain_entry = fresh_label(next_label);
+        match chain {
+            PostChain::NegFields(neg_fields) => {
+                emit_neg_fields_chain(chain_entry, current_succs, neg_fields, out, next_label);
+            }
+            PostChain::PostEffects(effects) => {
+                emit_effects_chain_to_succs(chain_entry, current_succs, effects, out, next_label);
+            }
+            PostChain::Successors(succs) => {
+                emit_successors_cascade(chain_entry, succs, out, next_label);
+                current_succs = vec![chain_entry];
+                continue;
+            }
+        }
+        current_succs = vec![chain_entry];
+    }
+
+    m.successors = current_succs;
+    out.push(m.into());
+}
+
+fn emit_effects_chain(
+    entry: Label,
+    exit: Label,
+    mut effects: Vec<EffectIR>,
+    out: &mut Vec<InstructionIR>,
+    next_label: &mut u32,
+) {
+    if effects.is_empty() {
+        out.push(MatchIR::epsilon(entry, exit).into());
+        return;
+    }
+
+    if effects.len() <= MAX_PRE_EFFECTS {
+        out.push(MatchIR::epsilon(entry, exit).pre_effects(effects).into());
+        return;
+    }
+
+    let first_batch: Vec<_> = effects.drain(..MAX_PRE_EFFECTS).collect();
+    let intermediate = fresh_label(next_label);
+    out.push(
+        MatchIR::epsilon(entry, intermediate)
+            .pre_effects(first_batch)
+            .into(),
+    );
+    emit_effects_chain(intermediate, exit, effects, out, next_label);
+}
+
+fn emit_neg_fields_chain(
+    entry: Label,
+    final_succs: Vec<Label>,
+    mut neg_fields: Vec<u16>,
+    out: &mut Vec<InstructionIR>,
+    next_label: &mut u32,
+) {
+    if neg_fields.len() <= MAX_NEG_FIELDS {
+        let mut m = MatchIR::at(entry).neg_fields(neg_fields);
+        m.successors = final_succs;
+        out.push(m.into());
+        return;
+    }
+
+    let first_batch: Vec<_> = neg_fields.drain(..MAX_NEG_FIELDS).collect();
+    let intermediate = fresh_label(next_label);
+    out.push(
+        MatchIR::at(entry)
+            .neg_fields(first_batch)
+            .next(intermediate)
+            .into(),
+    );
+    emit_neg_fields_chain(intermediate, final_succs, neg_fields, out, next_label);
+}
+
+fn emit_effects_chain_to_succs(
+    entry: Label,
+    final_succs: Vec<Label>,
+    mut effects: Vec<EffectIR>,
+    out: &mut Vec<InstructionIR>,
+    next_label: &mut u32,
+) {
+    if effects.len() <= MAX_POST_EFFECTS {
+        let mut m = MatchIR::at(entry).post_effects(effects);
+        m.successors = final_succs;
+        out.push(m.into());
+        return;
+    }
+
+    let first_batch: Vec<_> = effects.drain(..MAX_POST_EFFECTS).collect();
+    let intermediate = fresh_label(next_label);
+    out.push(
+        MatchIR::at(entry)
+            .post_effects(first_batch)
+            .next(intermediate)
+            .into(),
+    );
+    emit_effects_chain_to_succs(intermediate, final_succs, effects, out, next_label);
+}
+
+fn emit_successors_cascade(
+    entry: Label,
+    mut succs: Vec<Label>,
+    out: &mut Vec<InstructionIR>,
+    next_label: &mut u32,
+) {
+    if succs.len() <= MAX_MATCH_PAYLOAD_SLOTS {
+        out.push(MatchIR::at(entry).next_many(succs).into());
+        return;
+    }
+
+    let overflow: Vec<_> = succs.drain(MAX_MATCH_PAYLOAD_SLOTS - 1..).collect();
+    let intermediate = fresh_label(next_label);
+    succs.push(intermediate);
+    out.push(MatchIR::at(entry).next_many(succs).into());
+    emit_successors_cascade(intermediate, overflow, out, next_label);
+}
diff --git a/crates/plotnik-compiler/src/compile/lower_tests.rs b/crates/plotnik-compiler/src/compile/lower_tests.rs
new file mode 100644
index 0000000..a2eb730
--- /dev/null
+++ b/crates/plotnik-compiler/src/compile/lower_tests.rs
@@ -0,0 +1,171 @@
+//! Unit tests for the lowering pass.
+
+use plotnik_bytecode::{EffectOpcode, Nav, MAX_MATCH_PAYLOAD_SLOTS, MAX_PRE_EFFECTS};
+
+use super::lower::lower;
+use super::CompileResult;
+use crate::bytecode::{EffectIR, InstructionIR, Label, MatchIR};
+
+const MAX_POST_EFFECTS: usize = 7;
+const MAX_NEG_FIELDS: usize = 7;
+
+fn make_effect(_idx: u16) -> EffectIR {
+    EffectIR::simple(EffectOpcode::Null, 0)
+}
+
+#[test]
+fn lower_no_overflow_unchanged() {
+    let mut result = CompileResult {
+        instructions: vec![MatchIR::at(Label(0))
+            .pre_effects((0..3).map(make_effect))
+            .next(Label(1))
+            .into()],
+        def_entries: Default::default(),
+        preamble_entry: Label(0),
+    };
+
+    lower(&mut result);
+
+    assert_eq!(result.instructions.len(), 1);
+}
+
+#[test]
+fn lower_pre_effects_overflow() {
+    let mut result = CompileResult {
+        instructions: vec![MatchIR::at(Label(0))
+            .nav(Nav::Down)
+            .pre_effects((0..10).map(make_effect))
+            .next(Label(1))
+            .into()],
+        def_entries: Default::default(),
+        preamble_entry: Label(0),
+    };
+
+    lower(&mut result);
+
+    // Should split into: epsilon chain (2 steps) + actual match
+    assert!(result.instructions.len() >= 2);
+
+    // First instruction should be epsilon with effects
+    let first = result.instructions.first().unwrap();
+    if let InstructionIR::Match(m) = first {
+        assert!(m.nav == Nav::Epsilon);
+        assert!(m.pre_effects.len() <= MAX_PRE_EFFECTS);
+    } else {
+        panic!("expected Match");
+    }
+}
+
+#[test]
+fn lower_post_effects_overflow() {
+    let mut result = CompileResult {
+        instructions: vec![MatchIR::at(Label(0))
+            .nav(Nav::Down)
+            .post_effects((0..10).map(make_effect))
+            .next(Label(1))
+            .into()],
+        def_entries: Default::default(),
+        preamble_entry: Label(0),
+    };
+
+    lower(&mut result);
+
+    // Should split: match + epsilon chain for overflow post_effects
+    assert!(result.instructions.len() >= 2);
+
+    // All post_effects should be within limits
+    for instr in &result.instructions {
+        if let InstructionIR::Match(m) = instr {
+            assert!(
+                m.post_effects.len() <= MAX_POST_EFFECTS,
+                "post_effects {} > {}",
+                m.post_effects.len(),
+                MAX_POST_EFFECTS
+            );
+        }
+    }
+}
+
+#[test]
+fn lower_neg_fields_overflow() {
+    let mut result = CompileResult {
+        instructions: vec![MatchIR::at(Label(0))
+            .nav(Nav::Down)
+            .neg_fields(0..10)
+            .next(Label(1))
+            .into()],
+        def_entries: Default::default(),
+        preamble_entry: Label(0),
+    };
+
+    lower(&mut result);
+
+    // Should split: match + epsilon chain for overflow neg_fields
+    assert!(result.instructions.len() >= 2);
+
+    // All neg_fields should be within limits
+    for instr in &result.instructions {
+        if let InstructionIR::Match(m) = instr {
+            assert!(
+                m.neg_fields.len() <= MAX_NEG_FIELDS,
+                "neg_fields {} > {}",
+                m.neg_fields.len(),
+                MAX_NEG_FIELDS
+            );
+        }
+    }
+}
+
+#[test]
+fn lower_successors_overflow() {
+    let succs: Vec<_> = (1..=35).map(Label).collect();
+    let mut result = CompileResult {
+        instructions: vec![MatchIR::at(Label(0)).next_many(succs).into()],
+        def_entries: Default::default(),
+        preamble_entry: Label(0),
+    };
+
+    lower(&mut result);
+
+    // Should cascade into multiple epsilon instructions
+    assert!(result.instructions.len() >= 2);
+
+    // All successors should be within limits
+    for instr in &result.instructions {
+        if let InstructionIR::Match(m) = instr {
+            assert!(
+                m.successors.len() <= MAX_MATCH_PAYLOAD_SLOTS,
+                "successors {} > {}",
+                m.successors.len(),
+                MAX_MATCH_PAYLOAD_SLOTS
+            );
+        }
+    }
+}
+
+#[test]
+fn lower_combined_overflow() {
+    let mut result = CompileResult {
+        instructions: vec![MatchIR::at(Label(0))
+            .nav(Nav::Down)
+            .pre_effects((0..10).map(make_effect))
+            .post_effects((0..10).map(make_effect))
+            .neg_fields(0..10)
+            .next(Label(1))
+            .into()],
+        def_entries: Default::default(),
+        preamble_entry: Label(0),
+    };
+
+    lower(&mut result);
+
+    // Should handle all overflows
+    for instr in &result.instructions {
+        if let InstructionIR::Match(m) = instr {
+            assert!(m.pre_effects.len() <= MAX_PRE_EFFECTS);
+            assert!(m.post_effects.len() <= MAX_POST_EFFECTS);
+            assert!(m.neg_fields.len() <= MAX_NEG_FIELDS);
+            assert!(m.successors.len() <= MAX_MATCH_PAYLOAD_SLOTS);
+        }
+    }
+}
diff --git a/crates/plotnik-compiler/src/compile/mod.rs b/crates/plotnik-compiler/src/compile/mod.rs
index 31b3e69..bc9f48c 100644
--- a/crates/plotnik-compiler/src/compile/mod.rs
+++ b/crates/plotnik-compiler/src/compile/mod.rs
@@ -20,6 +20,7 @@ mod dce;
 pub(crate) mod epsilon_elim;
 mod error;
 mod expressions;
+mod lower;
 mod navigation;
 mod quantifier;
 mod scope;
@@ -30,6 +31,8 @@ mod verify;
 mod capture_tests;
 #[cfg(test)]
 mod compile_tests;
+#[cfg(test)]
+mod lower_tests;
 
 pub use capture::CaptureEffects;
 pub use compiler::{CompileCtx, Compiler};
diff --git a/crates/plotnik-compiler/src/compile/scope.rs b/crates/plotnik-compiler/src/compile/scope.rs
index 9faf45a..da8d57a 100644
--- a/crates/plotnik-compiler/src/compile/scope.rs
+++ b/crates/plotnik-compiler/src/compile/scope.rs
@@ -394,97 +394,23 @@ impl Compiler<'_> {
 
     /// Emit an epsilon transition (no node interaction).
     ///
-    /// If there are more successors than fit in a single Match instruction,
-    /// this creates a cascade of epsilon transitions to preserve NFA semantics.
+    /// Cascading for bytecode limits is handled by the lowering pass.
     pub(super) fn emit_epsilon(&mut self, label: Label, successors: Vec<Label>) {
-        use plotnik_bytecode::MAX_MATCH_PAYLOAD_SLOTS;
-
-        if successors.len() <= MAX_MATCH_PAYLOAD_SLOTS {
-            self.push_epsilon(label, successors);
-            return;
-        }
-
-        // Split: first (MAX-1) successors + intermediate for rest.
-        // This preserves priority order: VM tries s0, s1, ..., then intermediate.
-        let split_at = MAX_MATCH_PAYLOAD_SLOTS - 1;
-        let (first_batch, rest) = successors.split_at(split_at);
-
-        let intermediate = self.fresh_label();
-        self.emit_epsilon(intermediate, rest.to_vec());
-
-        let mut batch = first_batch.to_vec();
-        batch.push(intermediate);
-        self.push_epsilon(label, batch);
-    }
-
-    fn push_epsilon(&mut self, label: Label, successors: Vec<Label>) {
         self.instructions
             .push(MatchIR::at(label).next_many(successors).into());
     }
 
-    /// Emit a Match instruction, cascading pre-effects if they exceed the bytecode limit.
+    /// Emit a Match instruction.
     ///
-    /// When `pre_effects.len() > MAX_PRE_EFFECTS` (7), splits overflow into leading
-    /// epsilon transitions to avoid bytecode encoding overflow. The original label
-    /// is preserved as the entry point of the cascade.
+    /// Cascading for bytecode limits is handled by the lowering pass.
     ///
     /// Returns the entry label (same as `instr.label`).
-    pub(super) fn emit_match_with_cascade(&mut self, mut instr: MatchIR) -> Label {
-        use plotnik_bytecode::MAX_PRE_EFFECTS;
-
+    pub(super) fn emit_match(&mut self, instr: MatchIR) -> Label {
         let entry = instr.label;
-
-        if instr.pre_effects.len() <= MAX_PRE_EFFECTS {
-            self.instructions.push(instr.into());
-            return entry;
-        }
-
-        // Move all pre-effects to epsilon chain
-        let all_effects = std::mem::take(&mut instr.pre_effects);
-
-        // Create new label for the actual match instruction
-        let match_label = self.fresh_label();
-        instr.label = match_label;
         self.instructions.push(instr.into());
-
-        // Emit cascade from entry → ... → match_label
-        self.emit_effects_chain(entry, match_label, all_effects);
-
         entry
     }
 
-    /// Emit a chain of epsilon transitions to execute effects in order.
-    ///
-    /// Splits effects into batches of `MAX_PRE_EFFECTS` (7), emitting epsilon
-    /// transitions: `entry → intermediate1 → ... → exit`.
-    fn emit_effects_chain(&mut self, entry: Label, exit: Label, mut effects: Vec<EffectIR>) {
-        use plotnik_bytecode::MAX_PRE_EFFECTS;
-
-        if effects.is_empty() {
-            // Just link entry to exit
-            self.instructions.push(MatchIR::epsilon(entry, exit).into());
-            return;
-        }
-
-        if effects.len() <= MAX_PRE_EFFECTS {
-            self.instructions
-                .push(MatchIR::epsilon(entry, exit).pre_effects(effects).into());
-            return;
-        }
-
-        // Take first batch, recurse for rest
-        let first_batch: Vec<_> = effects.drain(..MAX_PRE_EFFECTS).collect();
-        let intermediate = self.fresh_label();
-
-        self.instructions.push(
-            MatchIR::epsilon(entry, intermediate)
-                .pre_effects(first_batch)
-                .into(),
-        );
-
-        self.emit_effects_chain(intermediate, exit, effects);
-    }
-
     /// Emit a wildcard navigation step that accepts any node.
     ///
     /// Used for skip-retry logic in quantifiers: navigates to the next position