diff --git a/Compilation/CompilationContext.cs b/Compilation/CompilationContext.cs
index db747eb..948215f 100644
--- a/Compilation/CompilationContext.cs
+++ b/Compilation/CompilationContext.cs
@@ -46,6 +46,12 @@ public class CompilationContext
     public TypeMapper TypeMapper { get; }
     public LocalsManager Locals { get; }
 
+    /// <summary>
+    /// Validated IL builder that wraps the ILGenerator with compile-time checks.
+    /// Use this for new code to catch label, stack, and exception block errors early.
+    /// </summary>
+    public ValidatedILBuilder ILBuilder { get; private set; }
+
     /// <summary>
     /// Type provider for resolving .NET types (runtime or reference assembly mode).
     /// Use this instead of typeof() for type resolution to support --ref-asm compilation.
@@ -416,6 +422,16 @@ public CompilationContext(
         Classes = classes;
         Types = types ?? TypeProvider.Runtime;
         Locals = new LocalsManager(il);
+        ILBuilder = new ValidatedILBuilder(il, Types);
+    }
+
+    /// <summary>
+    /// Updates the validated IL builder for a new ILGenerator (when switching methods).
+    /// Call this when the IL property changes to a new method's generator.
+    /// </summary>
+    public void UpdateILBuilder(ILGenerator newIL)
+    {
+        ILBuilder = new ValidatedILBuilder(newIL, Types);
     }
 
     public void DefineParameter(string name, int argIndex, Type? paramType = null)
diff --git a/Compilation/ILCompiler.Classes.Methods.cs b/Compilation/ILCompiler.Classes.Methods.cs
index c4e4e85..1211bb4 100644
--- a/Compilation/ILCompiler.Classes.Methods.cs
+++ b/Compilation/ILCompiler.Classes.Methods.cs
@@ -683,8 +683,9 @@ private void EmitMethod(TypeBuilder typeBuilder, Stmt.Function method, FieldInfo
             lockTakenLocal = il.DeclareLocal(typeof(bool));         // bool __lockTaken
 
             // Set up deferred return handling for the lock's exception block
+            // Use the builder to define the label so it's tracked for validation
             ctx.ReturnValueLocal = il.DeclareLocal(typeof(object));
-            ctx.ReturnLabel = il.DefineLabel();
+            ctx.ReturnLabel = ctx.ILBuilder.DefineLabel("lock_deferred_return");
             ctx.ExceptionBlockDepth++;
 
             // int __prevReentrancy = _lockReentrancy.Value;
@@ -719,8 +720,8 @@ private void EmitMethod(TypeBuilder typeBuilder, Stmt.Function method, FieldInfo
 
             il.MarkLabel(skipEnterLabel);
 
-            // Begin try block
-            il.BeginExceptionBlock();
+            // Begin try block - use builder to keep exception depth in sync
+            ctx.ILBuilder.BeginExceptionBlock();
         }
 
         // Abstract methods have no body to emit
@@ -740,10 +741,10 @@ private void EmitMethod(TypeBuilder typeBuilder, Stmt.Function method, FieldInfo
             // ReturnValueLocal is guaranteed non-null here (set up earlier in hasLock block)
             il.Emit(OpCodes.Ldnull);
             il.Emit(OpCodes.Stloc, ctx.ReturnValueLocal!);
-            il.Emit(OpCodes.Leave, ctx.ReturnLabel);
+            ctx.ILBuilder.Emit_Leave(ctx.ReturnLabel);
 
-            // Begin finally block
-            il.BeginFinallyBlock();
+            // Begin finally block - use builder for exception block tracking
+            ctx.ILBuilder.BeginFinallyBlock();
 
             // _lockReentrancy.Value = __prevReentrancy;
             il.Emit(OpCodes.Ldarg_0);                               // this
@@ -763,13 +764,13 @@ private void EmitMethod(TypeBuilder typeBuilder, Stmt.Function method, FieldInfo
 
             il.MarkLabel(skipExitLabel);
 
-            // End try/finally block
-            il.EndExceptionBlock();
+            // End try/finally block - use builder for exception block tracking
+            ctx.ILBuilder.EndExceptionBlock();
 
             ctx.ExceptionBlockDepth--;
 
-            // Mark return label and emit actual return
-            il.MarkLabel(ctx.ReturnLabel);
+            // Mark return label and emit actual return - use builder since label was defined with builder
+            ctx.ILBuilder.MarkLabel(ctx.ReturnLabel);
             il.Emit(OpCodes.Ldloc, ctx.ReturnValueLocal!);  // Non-null in hasLock path
             il.Emit(OpCodes.Ret);
         }
diff --git a/Compilation/ILCompiler.Classes.Static.cs b/Compilation/ILCompiler.Classes.Static.cs
index c9e2f5c..7699b79 100644
--- a/Compilation/ILCompiler.Classes.Static.cs
+++ b/Compilation/ILCompiler.Classes.Static.cs
@@ -221,8 +221,9 @@ private void EmitStaticMethodBody(string className, Stmt.Function method)
             lockTakenLocal = il.DeclareLocal(typeof(bool));         // bool __lockTaken
 
             // Set up deferred return handling for the lock's exception block
+            // Use the builder to define the label so it's tracked for validation
             ctx.ReturnValueLocal = il.DeclareLocal(typeof(object));
-            ctx.ReturnLabel = il.DefineLabel();
+            ctx.ReturnLabel = ctx.ILBuilder.DefineLabel("static_lock_deferred_return");
             ctx.ExceptionBlockDepth++;
 
             // int __prevReentrancy = _staticLockReentrancy.Value;
@@ -254,8 +255,8 @@ private void EmitStaticMethodBody(string className, Stmt.Function method)
 
             il.MarkLabel(skipEnterLabel);
 
-            // Begin try block
-            il.BeginExceptionBlock();
+            // Begin try block - use builder to keep exception depth in sync
+            ctx.ILBuilder.BeginExceptionBlock();
         }
 
         // Abstract methods have no body to emit
@@ -275,10 +276,10 @@ private void EmitStaticMethodBody(string className, Stmt.Function method)
             // ReturnValueLocal is guaranteed non-null here (set up earlier in hasLock block)
             il.Emit(OpCodes.Ldnull);
             il.Emit(OpCodes.Stloc, ctx.ReturnValueLocal!);
-            il.Emit(OpCodes.Leave, ctx.ReturnLabel);
+            ctx.ILBuilder.Emit_Leave(ctx.ReturnLabel);
 
-            // Begin finally block
-            il.BeginFinallyBlock();
+            // Begin finally block - use builder for exception block tracking
+            ctx.ILBuilder.BeginFinallyBlock();
 
             // _staticLockReentrancy.Value = __prevReentrancy;
             il.Emit(OpCodes.Ldsfld, staticReentrancyField);         // _staticLockReentrancy
@@ -296,13 +297,13 @@ private void EmitStaticMethodBody(string className, Stmt.Function method)
 
             il.MarkLabel(skipExitLabel);
 
-            // End try/finally block
-            il.EndExceptionBlock();
+            // End try/finally block - use builder for exception block tracking
+            ctx.ILBuilder.EndExceptionBlock();
 
             ctx.ExceptionBlockDepth--;
 
-            // Mark return label and emit actual return
-            il.MarkLabel(ctx.ReturnLabel);
+            // Mark return label and emit actual return - use builder since label was defined with builder
+            ctx.ILBuilder.MarkLabel(ctx.ReturnLabel);
             il.Emit(OpCodes.Ldloc, ctx.ReturnValueLocal!);  // Non-null in hasLock path
             il.Emit(OpCodes.Ret);
         }
diff --git a/Compilation/ILEmitter.Calls.cs b/Compilation/ILEmitter.Calls.cs
index e0f69fa..1b3432d 100644
--- a/Compilation/ILEmitter.Calls.cs
+++ b/Compilation/ILEmitter.Calls.cs
@@ -731,19 +731,20 @@ private void EmitAmbiguousMethodCall(Expr obj, string methodName, List<Expr> arg
         IL.Emit(OpCodes.Stloc, objLocal);
 
         // Check if it's a string
-        var isStringLabel = IL.DefineLabel();
-        var isListLabel = IL.DefineLabel();
-        var doneLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var isStringLabel = builder.DefineLabel("ambiguous_string");
+        var isListLabel = builder.DefineLabel("ambiguous_list");
+        var doneLabel = builder.DefineLabel("ambiguous_done");
 
         IL.Emit(OpCodes.Ldloc, objLocal);
         IL.Emit(OpCodes.Isinst, _ctx.Types.String);
-        IL.Emit(OpCodes.Brtrue, isStringLabel);
+        builder.Emit_Brtrue(isStringLabel);
 
         // Assume it's a list if not a string
-        IL.Emit(OpCodes.Br, isListLabel);
+        builder.Emit_Br(isListLabel);
 
         // String path
-        IL.MarkLabel(isStringLabel);
+        builder.MarkLabel(isStringLabel);
         IL.Emit(OpCodes.Ldloc, objLocal);
         IL.Emit(OpCodes.Castclass, _ctx.Types.String);
 
@@ -811,10 +812,10 @@ private void EmitAmbiguousMethodCall(Expr obj, string methodName, List<Expr> arg
                 IL.Emit(OpCodes.Call, _ctx.Runtime!.StringConcat);
                 break;
         }
-        IL.Emit(OpCodes.Br, doneLabel);
+        builder.Emit_Br(doneLabel);
 
         // List path
-        IL.MarkLabel(isListLabel);
+        builder.MarkLabel(isListLabel);
         IL.Emit(OpCodes.Ldloc, objLocal);
         IL.Emit(OpCodes.Castclass, _ctx.Types.ListOfObject);
 
@@ -877,7 +878,7 @@ private void EmitAmbiguousMethodCall(Expr obj, string methodName, List<Expr> arg
                 break;
         }
 
-        IL.MarkLabel(doneLabel);
+        builder.MarkLabel(doneLabel);
     }
 
     /// <summary>
diff --git a/Compilation/ILEmitter.Expressions.cs b/Compilation/ILEmitter.Expressions.cs
index 99045af..a985bea 100644
--- a/Compilation/ILEmitter.Expressions.cs
+++ b/Compilation/ILEmitter.Expressions.cs
@@ -163,8 +163,9 @@ protected override void EmitSuper(Expr.Super s)
 
     protected override void EmitTernary(Expr.Ternary t)
     {
-        var elseLabel = IL.DefineLabel();
-        var endLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var elseLabel = builder.DefineLabel("ternary_else");
+        var endLabel = builder.DefineLabel("ternary_end");
 
         EmitExpression(t.Condition);
         // Handle condition based on what's actually on the stack
@@ -187,35 +188,36 @@ protected override void EmitTernary(Expr.Ternary t)
             EnsureBoxed(); // Ensure it's boxed first
             EmitTruthyCheck();
         }
-        IL.Emit(OpCodes.Brfalse, elseLabel);
+        builder.Emit_Brfalse(elseLabel);
 
         EmitExpression(t.ThenBranch);
         EmitBoxIfNeeded(t.ThenBranch);
-        IL.Emit(OpCodes.Br, endLabel);
+        builder.Emit_Br(endLabel);
 
-        IL.MarkLabel(elseLabel);
+        builder.MarkLabel(elseLabel);
         EmitExpression(t.ElseBranch);
         EmitBoxIfNeeded(t.ElseBranch);
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
         // Both branches box, so result is Unknown (boxed object)
         SetStackUnknown();
     }
 
     protected override void EmitNullishCoalescing(Expr.NullishCoalescing nc)
     {
-        var endLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var endLabel = builder.DefineLabel("nullish_end");
 
         EmitExpression(nc.Left);
         EmitBoxIfNeeded(nc.Left);
         IL.Emit(OpCodes.Dup);
-        IL.Emit(OpCodes.Brtrue, endLabel);
+        builder.Emit_Brtrue(endLabel);
 
         IL.Emit(OpCodes.Pop);
         EmitExpression(nc.Right);
         EmitBoxIfNeeded(nc.Right);
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
         // Both branches box, so result is Unknown (boxed object)
         SetStackUnknown();
     }
diff --git a/Compilation/ILEmitter.Helpers.cs b/Compilation/ILEmitter.Helpers.cs
index 1e7f938..2fef7e9 100644
--- a/Compilation/ILEmitter.Helpers.cs
+++ b/Compilation/ILEmitter.Helpers.cs
@@ -15,7 +15,8 @@ public void FinalizeReturns()
         if (_ctx.ReturnValueLocal != null)
         {
             // Mark the return label and emit the actual return
-            IL.MarkLabel(_ctx.ReturnLabel);
+            // Use builder's MarkLabel since ReturnLabel was defined with builder
+            _ctx.ILBuilder.MarkLabel(_ctx.ReturnLabel);
             IL.Emit(OpCodes.Ldloc, _ctx.ReturnValueLocal);
             IL.Emit(OpCodes.Ret);
         }
@@ -33,6 +34,7 @@ public void FinalizeReturns()
     public void EmitDefaultParameters(List<Stmt.Parameter> parameters, bool isInstanceMethod)
     {
         int argOffset = isInstanceMethod ? 1 : 0;
+        var builder = _ctx.ILBuilder;
 
         for (int i = 0; i < parameters.Count; i++)
         {
@@ -42,18 +44,18 @@ public void EmitDefaultParameters(List<Stmt.Parameter> parameters, bool isInstan
             int argIndex = i + argOffset;
 
             // if (arg == null) { arg = <default>; }
-            var skipDefault = IL.DefineLabel();
+            var skipDefault = builder.DefineLabel($"skip_default_{i}");
 
             // Load argument and check if null
             IL.Emit(OpCodes.Ldarg, argIndex);
-            IL.Emit(OpCodes.Brtrue, skipDefault);
+            builder.Emit_Brtrue(skipDefault);
 
             // Argument is null, emit default value and store
             EmitExpression(param.DefaultValue);
             EmitBoxIfNeeded(param.DefaultValue);
             IL.Emit(OpCodes.Starg, argIndex);
 
-            IL.MarkLabel(skipDefault);
+            builder.MarkLabel(skipDefault);
         }
     }
 
@@ -296,35 +298,36 @@ protected override void EmitTruthyCheck()
         // - null => false
         // - boxed false => false
         // - everything else => true
-        var checkBoolLabel = IL.DefineLabel();
-        var falseLabel = IL.DefineLabel();
-        var endLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var checkBoolLabel = builder.DefineLabel("truthy_checkbool");
+        var falseLabel = builder.DefineLabel("truthy_false");
+        var endLabel = builder.DefineLabel("truthy_end");
 
         // Check for null
         IL.Emit(OpCodes.Dup);
-        IL.Emit(OpCodes.Brfalse, falseLabel);
+        builder.Emit_Brfalse(falseLabel);
 
         // Check if it's a boolean
         IL.Emit(OpCodes.Dup);
         IL.Emit(OpCodes.Isinst, _ctx.Types.Boolean);
-        IL.Emit(OpCodes.Brfalse, checkBoolLabel);
+        builder.Emit_Brfalse(checkBoolLabel);
 
         // It's a boxed bool - unbox and use the value
         IL.Emit(OpCodes.Unbox_Any, _ctx.Types.Boolean);
-        IL.Emit(OpCodes.Br, endLabel);
+        builder.Emit_Br(endLabel);
 
-        IL.MarkLabel(checkBoolLabel);
+        builder.MarkLabel(checkBoolLabel);
         // Not null and not bool - always truthy
         IL.Emit(OpCodes.Pop);
         IL.Emit(OpCodes.Ldc_I4_1);
-        IL.Emit(OpCodes.Br, endLabel);
+        builder.Emit_Br(endLabel);
 
-        IL.MarkLabel(falseLabel);
+        builder.MarkLabel(falseLabel);
         // Null - false
         IL.Emit(OpCodes.Pop);
         IL.Emit(OpCodes.Ldc_I4_0);
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
     }
 
     private static bool IsComparisonOp(TokenType op) =>
diff --git a/Compilation/ILEmitter.Operators.cs b/Compilation/ILEmitter.Operators.cs
index f0331f4..5567da5 100644
--- a/Compilation/ILEmitter.Operators.cs
+++ b/Compilation/ILEmitter.Operators.cs
@@ -156,7 +156,8 @@ private bool IsComparisonExpr(Expr expr)
 
     protected override void EmitLogical(Expr.Logical l)
     {
-        var endLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var endLabel = builder.DefineLabel("logical_end");
 
         EmitExpression(l.Left);
         EmitBoxIfNeeded(l.Left);
@@ -166,19 +167,19 @@ protected override void EmitLogical(Expr.Logical l)
         if (l.Operator.Type == TokenType.AND_AND)
         {
             // Short-circuit: if left is falsy, return left
-            IL.Emit(OpCodes.Brfalse, endLabel);
+            builder.Emit_Brfalse(endLabel);
         }
         else // OR
         {
             // Short-circuit: if left is truthy, return left
-            IL.Emit(OpCodes.Brtrue, endLabel);
+            builder.Emit_Brtrue(endLabel);
         }
 
         IL.Emit(OpCodes.Pop); // Pop the duplicate left value
         EmitExpression(l.Right);
         EmitBoxIfNeeded(l.Right);
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
         SetStackUnknown(); // Logical operators return boxed object
     }
 
diff --git a/Compilation/ILEmitter.Properties.cs b/Compilation/ILEmitter.Properties.cs
index 7978c60..2c43d98 100644
--- a/Compilation/ILEmitter.Properties.cs
+++ b/Compilation/ILEmitter.Properties.cs
@@ -162,21 +162,22 @@ protected override void EmitGet(Expr.Get g)
 
         if (g.Optional)
         {
-            var nullLabel = IL.DefineLabel();
-            var endLabel = IL.DefineLabel();
+            var builder = _ctx.ILBuilder;
+            var nullLabel = builder.DefineLabel("optional_null");
+            var endLabel = builder.DefineLabel("optional_end");
 
             IL.Emit(OpCodes.Dup);
-            IL.Emit(OpCodes.Brfalse, nullLabel);
+            builder.Emit_Brfalse(nullLabel);
 
             IL.Emit(OpCodes.Ldstr, g.Name.Lexeme);
             IL.Emit(OpCodes.Call, _ctx.Runtime!.GetProperty);
-            IL.Emit(OpCodes.Br, endLabel);
+            builder.Emit_Br(endLabel);
 
-            IL.MarkLabel(nullLabel);
+            builder.MarkLabel(nullLabel);
             IL.Emit(OpCodes.Pop);
             IL.Emit(OpCodes.Ldnull);
 
-            IL.MarkLabel(endLabel);
+            builder.MarkLabel(endLabel);
         }
         else
         {
diff --git a/Compilation/ILEmitter.Statements.cs b/Compilation/ILEmitter.Statements.cs
index 3d5a179..628bc36 100644
--- a/Compilation/ILEmitter.Statements.cs
+++ b/Compilation/ILEmitter.Statements.cs
@@ -106,8 +106,9 @@ protected override void EmitIf(Stmt.If i)
         }
 
         // BothReachable: emit both branches with condition check
-        var elseLabel = IL.DefineLabel();
-        var endLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var elseLabel = builder.DefineLabel("if_else");
+        var endLabel = builder.DefineLabel("if_end");
 
         EmitExpression(i.Condition);
         // Handle condition based on what's actually on the stack
@@ -130,28 +131,29 @@ protected override void EmitIf(Stmt.If i)
             EnsureBoxed();
             EmitTruthyCheck();
         }
-        IL.Emit(OpCodes.Brfalse, elseLabel);
+        builder.Emit_Brfalse(elseLabel);
 
         EmitStatement(i.ThenBranch);
-        IL.Emit(OpCodes.Br, endLabel);
+        builder.Emit_Br(endLabel);
 
-        IL.MarkLabel(elseLabel);
+        builder.MarkLabel(elseLabel);
         if (i.ElseBranch != null)
         {
             EmitStatement(i.ElseBranch);
         }
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
     }
 
     protected override void EmitWhile(Stmt.While w)
     {
-        var startLabel = IL.DefineLabel();
-        var endLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var startLabel = builder.DefineLabel("while_start");
+        var endLabel = builder.DefineLabel("while_end");
 
         _ctx.EnterLoop(endLabel, startLabel);
 
-        IL.MarkLabel(startLabel);
+        builder.MarkLabel(startLabel);
         EmitExpression(w.Condition);
         // Handle condition based on what's actually on the stack
         if (_stackType == StackType.Boolean)
@@ -173,29 +175,30 @@ protected override void EmitWhile(Stmt.While w)
             EnsureBoxed();
             EmitTruthyCheck();
         }
-        IL.Emit(OpCodes.Brfalse, endLabel);
+        builder.Emit_Brfalse(endLabel);
 
         EmitStatement(w.Body);
-        IL.Emit(OpCodes.Br, startLabel);
+        builder.Emit_Br(startLabel);
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
         _ctx.ExitLoop();
     }
 
     protected override void EmitDoWhile(Stmt.DoWhile dw)
     {
-        var startLabel = IL.DefineLabel();
-        var endLabel = IL.DefineLabel();
-        var continueLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var startLabel = builder.DefineLabel("dowhile_start");
+        var endLabel = builder.DefineLabel("dowhile_end");
+        var continueLabel = builder.DefineLabel("dowhile_continue");
 
         _ctx.EnterLoop(endLabel, continueLabel);
 
         // Body executes at least once
-        IL.MarkLabel(startLabel);
+        builder.MarkLabel(startLabel);
         EmitStatement(dw.Body);
 
         // Continue target is after the body, before condition check
-        IL.MarkLabel(continueLabel);
+        builder.MarkLabel(continueLabel);
 
         // Evaluate condition
         EmitExpression(dw.Condition);
@@ -219,15 +222,16 @@ protected override void EmitDoWhile(Stmt.DoWhile dw)
             EnsureBoxed();
             EmitTruthyCheck();
         }
-        IL.Emit(OpCodes.Brtrue, startLabel);
+        builder.Emit_Brtrue(startLabel);
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
         _ctx.ExitLoop();
     }
 
     protected override void EmitForOf(Stmt.ForOf f)
     {
         _ctx.Locals.EnterScope();
+        var builder = _ctx.ILBuilder;
 
         // Evaluate iterable
         TypeInfo? iterableType = _ctx.TypeMap?.Get(f.Iterable);
@@ -248,9 +252,9 @@ protected override void EmitForOf(Stmt.ForOf f)
         // For generators, use enumerator-based iteration (with its own labels)
         if (iterableType is TypeInfo.Generator)
         {
-            var genStartLabel = IL.DefineLabel();
-            var genEndLabel = IL.DefineLabel();
-            var genContinueLabel = IL.DefineLabel();
+            var genStartLabel = builder.DefineLabel("forof_gen_start");
+            var genEndLabel = builder.DefineLabel("forof_gen_end");
+            var genContinueLabel = builder.DefineLabel("forof_gen_continue");
             _ctx.EnterLoop(genEndLabel, genContinueLabel);
             EmitForOfEnumerator(f, genStartLabel, genEndLabel, genContinueLabel);
             return;
@@ -262,8 +266,8 @@ protected override void EmitForOf(Stmt.ForOf f)
 
         // Try iterator protocol first: GetIteratorFunction(iterable, Symbol.iterator)
         var iteratorFnLocal = IL.DeclareLocal(_ctx.Types.Object);
-        var indexBasedLabel = IL.DefineLabel();
-        var afterLoopLabel = IL.DefineLabel();
+        var indexBasedLabel = builder.DefineLabel("forof_index_based");
+        var afterLoopLabel = builder.DefineLabel("forof_after");
 
         IL.Emit(OpCodes.Ldloc, iterableLocal);
         IL.Emit(OpCodes.Ldsfld, _ctx.Runtime!.SymbolIterator);
@@ -272,13 +276,13 @@ protected override void EmitForOf(Stmt.ForOf f)
 
         // If iterator function is null, fall back to index-based iteration
         IL.Emit(OpCodes.Ldloc, iteratorFnLocal);
-        IL.Emit(OpCodes.Brfalse, indexBasedLabel);
+        builder.Emit_Brfalse(indexBasedLabel);
 
         // ===== Iterator protocol path =====
         {
-            var iterStartLabel = IL.DefineLabel();
-            var iterEndLabel = IL.DefineLabel();
-            var iterContinueLabel = IL.DefineLabel();
+            var iterStartLabel = builder.DefineLabel("forof_iter_start");
+            var iterEndLabel = builder.DefineLabel("forof_iter_end");
+            var iterContinueLabel = builder.DefineLabel("forof_iter_continue");
             _ctx.EnterLoop(iterEndLabel, iterContinueLabel);
 
             // Call the iterator function to get the iterator object
@@ -311,12 +315,12 @@ protected override void EmitForOf(Stmt.ForOf f)
             var moveNext = _ctx.Types.GetMethod(_ctx.Types.IEnumerator, "MoveNext");
             var current = _ctx.Types.IEnumerator.GetProperty("Current")!.GetGetMethod()!;
 
-            IL.MarkLabel(iterStartLabel);
+            builder.MarkLabel(iterStartLabel);
 
             // Call MoveNext
             IL.Emit(OpCodes.Ldloc, enumLocal);
             IL.Emit(OpCodes.Callvirt, moveNext);
-            IL.Emit(OpCodes.Brfalse, iterEndLabel);
+            builder.Emit_Brfalse(iterEndLabel);
 
             // Get Current
             IL.Emit(OpCodes.Ldloc, enumLocal);
@@ -326,20 +330,20 @@ protected override void EmitForOf(Stmt.ForOf f)
             // Emit body
             EmitStatement(f.Body);
 
-            IL.MarkLabel(iterContinueLabel);
-            IL.Emit(OpCodes.Br, iterStartLabel);
+            builder.MarkLabel(iterContinueLabel);
+            builder.Emit_Br(iterStartLabel);
 
-            IL.MarkLabel(iterEndLabel);
+            builder.MarkLabel(iterEndLabel);
             _ctx.ExitLoop();
-            IL.Emit(OpCodes.Br, afterLoopLabel); // Skip the index-based path
+            builder.Emit_Br(afterLoopLabel); // Skip the index-based path
         }
 
         // ===== Index-based fallback (for arrays, strings, etc.) =====
-        IL.MarkLabel(indexBasedLabel);
+        builder.MarkLabel(indexBasedLabel);
         {
-            var startLabel = IL.DefineLabel();
-            var endLabel = IL.DefineLabel();
-            var continueLabel = IL.DefineLabel();
+            var startLabel = builder.DefineLabel("forof_idx_start");
+            var endLabel = builder.DefineLabel("forof_idx_end");
+            var continueLabel = builder.DefineLabel("forof_idx_continue");
             _ctx.EnterLoop(endLabel, continueLabel);
 
             // Create index variable
@@ -350,14 +354,14 @@ protected override void EmitForOf(Stmt.ForOf f)
             // Loop variable
             var indexLoopVar = _ctx.Locals.DeclareLocal(f.Variable.Lexeme, _ctx.Types.Object);
 
-            IL.MarkLabel(startLabel);
+            builder.MarkLabel(startLabel);
 
             // Check if index < length
             IL.Emit(OpCodes.Ldloc, indexLocal);
             IL.Emit(OpCodes.Ldloc, iterableLocal);
             IL.Emit(OpCodes.Call, _ctx.Runtime!.GetLength);
             IL.Emit(OpCodes.Clt);
-            IL.Emit(OpCodes.Brfalse, endLabel);
+            builder.Emit_Brfalse(endLabel);
 
             // Get current element
             IL.Emit(OpCodes.Ldloc, iterableLocal);
@@ -368,7 +372,7 @@ protected override void EmitForOf(Stmt.ForOf f)
             // Emit body
             EmitStatement(f.Body);
 
-            IL.MarkLabel(continueLabel);
+            builder.MarkLabel(continueLabel);
 
             // Increment index
             IL.Emit(OpCodes.Ldloc, indexLocal);
@@ -376,19 +380,21 @@ protected override void EmitForOf(Stmt.ForOf f)
             IL.Emit(OpCodes.Add);
             IL.Emit(OpCodes.Stloc, indexLocal);
 
-            IL.Emit(OpCodes.Br, startLabel);
+            builder.Emit_Br(startLabel);
 
-            IL.MarkLabel(endLabel);
+            builder.MarkLabel(endLabel);
             _ctx.ExitLoop();
         }
 
         // Common exit point for both paths
-        IL.MarkLabel(afterLoopLabel);
+        builder.MarkLabel(afterLoopLabel);
         _ctx.Locals.ExitScope();
     }
 
     private void EmitForOfEnumerator(Stmt.ForOf f, Label startLabel, Label endLabel, Label continueLabel)
     {
+        var builder = _ctx.ILBuilder;
+
         // Use IEnumerable.GetEnumerator()/MoveNext()/Current pattern for generators
         var getEnumerator = _ctx.Types.GetMethod(_ctx.Types.IEnumerable, "GetEnumerator");
         var moveNext = _ctx.Types.GetMethod(_ctx.Types.IEnumerator, "MoveNext");
@@ -404,12 +410,12 @@ private void EmitForOfEnumerator(Stmt.ForOf f, Label startLabel, Label endLabel,
         // Loop variable
         var loopVar = _ctx.Locals.DeclareLocal(f.Variable.Lexeme, _ctx.Types.Object);
 
-        IL.MarkLabel(startLabel);
+        builder.MarkLabel(startLabel);
 
         // Call MoveNext
         IL.Emit(OpCodes.Ldloc, enumLocal);
         IL.Emit(OpCodes.Callvirt, moveNext);
-        IL.Emit(OpCodes.Brfalse, endLabel);
+        builder.Emit_Brfalse(endLabel);
 
         // Get Current
         IL.Emit(OpCodes.Ldloc, enumLocal);
@@ -419,19 +425,20 @@ private void EmitForOfEnumerator(Stmt.ForOf f, Label startLabel, Label endLabel,
         // Emit body
         EmitStatement(f.Body);
 
-        IL.MarkLabel(continueLabel);
-        IL.Emit(OpCodes.Br, startLabel);
+        builder.MarkLabel(continueLabel);
+        builder.Emit_Br(startLabel);
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
         _ctx.Locals.ExitScope();
         _ctx.ExitLoop();
     }
 
     protected override void EmitForIn(Stmt.ForIn f)
     {
-        var startLabel = IL.DefineLabel();
-        var endLabel = IL.DefineLabel();
-        var continueLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var startLabel = builder.DefineLabel("forin_start");
+        var endLabel = builder.DefineLabel("forin_end");
+        var continueLabel = builder.DefineLabel("forin_continue");
 
         _ctx.EnterLoop(endLabel, continueLabel);
         _ctx.Locals.EnterScope();
@@ -450,14 +457,14 @@ protected override void EmitForIn(Stmt.ForIn f)
         // Loop variable (holds current key)
         var loopVar = _ctx.Locals.DeclareLocal(f.Variable.Lexeme, _ctx.Types.Object);
 
-        IL.MarkLabel(startLabel);
+        builder.MarkLabel(startLabel);
 
         // Check if index < keys.Count
         IL.Emit(OpCodes.Ldloc, indexLocal);
         IL.Emit(OpCodes.Ldloc, keysLocal);
         IL.Emit(OpCodes.Call, _ctx.Runtime!.GetLength);
         IL.Emit(OpCodes.Clt);
-        IL.Emit(OpCodes.Brfalse, endLabel);
+        builder.Emit_Brfalse(endLabel);
 
         // Get current key: keys[index]
         IL.Emit(OpCodes.Ldloc, keysLocal);
@@ -468,7 +475,7 @@ protected override void EmitForIn(Stmt.ForIn f)
         // Emit body
         EmitStatement(f.Body);
 
-        IL.MarkLabel(continueLabel);
+        builder.MarkLabel(continueLabel);
 
         // Increment index
         IL.Emit(OpCodes.Ldloc, indexLocal);
@@ -476,9 +483,9 @@ protected override void EmitForIn(Stmt.ForIn f)
         IL.Emit(OpCodes.Add);
         IL.Emit(OpCodes.Stloc, indexLocal);
 
-        IL.Emit(OpCodes.Br, startLabel);
+        builder.Emit_Br(startLabel);
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
         _ctx.Locals.ExitScope();
         _ctx.ExitLoop();
     }
@@ -508,13 +515,15 @@ protected override void EmitReturn(Stmt.Return r)
         if (_ctx.ExceptionBlockDepth > 0)
         {
             // Inside exception block: store value and leave
+            // Use builder for Leave validation (ensures we're inside exception block)
+            var builder = _ctx.ILBuilder;
             if (_ctx.ReturnValueLocal == null)
             {
                 _ctx.ReturnValueLocal = IL.DeclareLocal(_ctx.Types.Object);
-                _ctx.ReturnLabel = IL.DefineLabel();
+                _ctx.ReturnLabel = builder.DefineLabel("deferred_return");
             }
             IL.Emit(OpCodes.Stloc, _ctx.ReturnValueLocal);
-            IL.Emit(OpCodes.Leave, _ctx.ReturnLabel);
+            builder.Emit_Leave(_ctx.ReturnLabel);
         }
         else
         {
@@ -545,15 +554,16 @@ protected override void EmitContinue(Stmt.Continue c)
     protected override void EmitLabeledStatement(Stmt.LabeledStatement labeledStmt)
     {
         string labelName = labeledStmt.Label.Lexeme;
-        var breakLabel = IL.DefineLabel();
-        var continueLabel = IL.DefineLabel();
+        var builder = _ctx.ILBuilder;
+        var breakLabel = builder.DefineLabel($"labeled_{labelName}_break");
+        var continueLabel = builder.DefineLabel($"labeled_{labelName}_continue");
 
         // For labeled statements, we need to handle both loops and non-loop statements.
         // For loops, the inner loop will use its own labels for unlabeled break/continue,
         // but labeled break/continue should use the labels registered here.
 
         // Mark continue label at the start (for labeled continue, restart from here)
-        IL.MarkLabel(continueLabel);
+        builder.MarkLabel(continueLabel);
 
         _ctx.EnterLoop(breakLabel, continueLabel, labelName);
         try
@@ -568,7 +578,7 @@ protected override void EmitLabeledStatement(Stmt.LabeledStatement labeledStmt)
         }
 
         // Mark the break label (after the statement, for labeled break)
-        IL.MarkLabel(breakLabel);
+        builder.MarkLabel(breakLabel);
     }
 
     protected override void EmitSwitch(Stmt.Switch s)
@@ -577,9 +587,10 @@ protected override void EmitSwitch(Stmt.Switch s)
         var switchAnalysis = _ctx.DeadCode?.GetSwitchResult(s);
         bool skipDefault = switchAnalysis?.DefaultIsUnreachable == true;
 
-        var endLabel = IL.DefineLabel();
-        var defaultLabel = IL.DefineLabel();
-        var caseLabels = s.Cases.Select(_ => IL.DefineLabel()).ToList();
+        var builder = _ctx.ILBuilder;
+        var endLabel = builder.DefineLabel("switch_end");
+        var defaultLabel = builder.DefineLabel("switch_default");
+        var caseLabels = s.Cases.Select((_, i) => builder.DefineLabel($"switch_case_{i}")).ToList();
 
         // Evaluate subject once
         EmitExpression(s.Subject);
@@ -594,23 +605,23 @@ protected override void EmitSwitch(Stmt.Switch s)
             EmitExpression(s.Cases[i].Value);
             EmitBoxIfNeeded(s.Cases[i].Value);
             IL.Emit(OpCodes.Call, _ctx.Runtime!.Equals);
-            IL.Emit(OpCodes.Brtrue, caseLabels[i]);
+            builder.Emit_Brtrue(caseLabels[i]);
         }
 
         // Jump to default or end (skip default if unreachable)
         if (skipDefault || s.DefaultBody == null)
         {
-            IL.Emit(OpCodes.Br, endLabel);
+            builder.Emit_Br(endLabel);
         }
         else
         {
-            IL.Emit(OpCodes.Br, defaultLabel);
+            builder.Emit_Br(defaultLabel);
         }
 
         // Emit case bodies
         for (int i = 0; i < s.Cases.Count; i++)
         {
-            IL.MarkLabel(caseLabels[i]);
+            builder.MarkLabel(caseLabels[i]);
             foreach (var stmt in s.Cases[i].Body)
             {
                 if (stmt is Stmt.Break breakStmt)
@@ -623,7 +634,7 @@ protected override void EmitSwitch(Stmt.Switch s)
                     else
                     {
                         // Unlabeled break - exits switch only
-                        IL.Emit(OpCodes.Br, endLabel);
+                        builder.Emit_Br(endLabel);
                     }
                 }
                 else
@@ -637,7 +648,7 @@ protected override void EmitSwitch(Stmt.Switch s)
         // Default case (skip if unreachable)
         if (s.DefaultBody != null && !skipDefault)
         {
-            IL.MarkLabel(defaultLabel);
+            builder.MarkLabel(defaultLabel);
             foreach (var stmt in s.DefaultBody)
             {
                 if (stmt is Stmt.Break breakStmt)
@@ -650,7 +661,7 @@ protected override void EmitSwitch(Stmt.Switch s)
                     else
                     {
                         // Unlabeled break - exits switch only
-                        IL.Emit(OpCodes.Br, endLabel);
+                        builder.Emit_Br(endLabel);
                     }
                 }
                 else
@@ -660,14 +671,17 @@ protected override void EmitSwitch(Stmt.Switch s)
             }
         }
 
-        IL.MarkLabel(endLabel);
+        builder.MarkLabel(endLabel);
     }
 
     protected override void EmitTryCatch(Stmt.TryCatch t)
     {
-        _ctx.ExceptionBlockDepth++;
+        // Use ValidatedILBuilder for exception block operations - it tracks depth automatically
+        // and validates proper Begin/End pairing
+        var builder = _ctx.ILBuilder;
 
-        IL.BeginExceptionBlock();
+        _ctx.ExceptionBlockDepth++;
+        builder.BeginExceptionBlock();
 
         foreach (var stmt in t.TryBlock)
         {
@@ -676,7 +690,7 @@ protected override void EmitTryCatch(Stmt.TryCatch t)
 
         if (t.CatchBlock != null)
         {
-            IL.BeginCatchBlock(_ctx.Types.Exception);
+            builder.BeginCatchBlock(_ctx.Types.Exception);
 
             if (t.CatchParam != null)
             {
@@ -698,15 +712,14 @@ protected override void EmitTryCatch(Stmt.TryCatch t)
 
         if (t.FinallyBlock != null)
         {
-            IL.BeginFinallyBlock();
+            builder.BeginFinallyBlock();
             foreach (var stmt in t.FinallyBlock)
             {
                 EmitStatement(stmt);
             }
         }
 
-        IL.EndExceptionBlock();
-
+        builder.EndExceptionBlock();
         _ctx.ExceptionBlockDepth--;
     }
 
diff --git a/Compilation/ILEmitter.cs b/Compilation/ILEmitter.cs
index 5b8e1df..7e46358 100644
--- a/Compilation/ILEmitter.cs
+++ b/Compilation/ILEmitter.cs
@@ -57,7 +57,7 @@ private StackType _stackType
     }
 
     public ILEmitter(CompilationContext ctx)
-        : base(new StateMachineEmitHelpers(ctx.IL, ctx.Types))
+        : base(new StateMachineEmitHelpers(ctx.IL, ctx.Types, ctx.ILBuilder))
     {
         _ctx = ctx;
         _resolver = new LocalVariableResolver(ctx.IL, ctx, ctx.Types);
@@ -86,11 +86,12 @@ protected override bool IsDead(Stmt stmt)
 
     protected override void EmitBranchToLabel(Label target)
     {
-        // Use Leave instead of Br when inside exception blocks
+        // Use builder for branch validation - it enforces Leave vs Br rules
+        var builder = _ctx.ILBuilder;
         if (_ctx.ExceptionBlockDepth > 0)
-            IL.Emit(OpCodes.Leave, target);
+            builder.Emit_Leave(target);
         else
-            IL.Emit(OpCodes.Br, target);
+            builder.Emit_Br(target);
     }
 
     protected override LocalBuilder? DeclareLoopVariable(string name)
diff --git a/Compilation/ILValidationException.cs b/Compilation/ILValidationException.cs
new file mode 100644
index 0000000..3e2fa1f
--- /dev/null
+++ b/Compilation/ILValidationException.cs
@@ -0,0 +1,42 @@
+namespace SharpTS.Compilation;
+
+/// <summary>
+/// Exception thrown when IL validation fails during emit.
+/// </summary>
+/// <remarks>
+/// This exception is thrown by <see cref="ValidatedILBuilder"/> when it detects
+/// an invalid IL emission pattern at compile time. The error is caught early,
+/// before the generated assembly would fail PEVerify or crash at runtime.
+///
+/// <para>Common causes:</para>
+/// <list type="bullet">
+/// <item>A label was defined but never marked (forgotten MarkLabel call)</item>
+/// <item>Stack depth mismatch at a branch target (inconsistent code paths)</item>
+/// <item>Using Br inside an exception block (should use Leave)</item>
+/// <item>Using Leave outside an exception block</item>
+/// <item>Attempting to Box a reference type</item>
+/// <item>Attempting to Unbox a value type</item>
+/// <item>Insufficient values on the stack for an operation</item>
+/// </list>
+/// </remarks>
+public class ILValidationException : Exception
+{
+    /// <summary>
+    /// Creates a new IL validation exception.
+    /// </summary>
+    /// <param name="message">Description of the validation failure.</param>
+    public ILValidationException(string message)
+        : base($"IL Validation Error: {message}")
+    {
+    }
+
+    /// <summary>
+    /// Creates a new IL validation exception with an inner exception.
+    /// </summary>
+    /// <param name="message">Description of the validation failure.</param>
+    /// <param name="innerException">The underlying exception.</param>
+    public ILValidationException(string message, Exception innerException)
+        : base($"IL Validation Error: {message}", innerException)
+    {
+    }
+}
diff --git a/Compilation/StateMachineEmitHelpers.cs b/Compilation/StateMachineEmitHelpers.cs
index a30c8eb..e8be171 100644
--- a/Compilation/StateMachineEmitHelpers.cs
+++ b/Compilation/StateMachineEmitHelpers.cs
@@ -11,6 +11,7 @@ public class StateMachineEmitHelpers
 {
     private readonly ILGenerator _il;
     private readonly TypeProvider _types;
+    private readonly ValidatedILBuilder? _builder;
     private StackType _stackType = StackType.Unknown;
 
     /// <summary>
@@ -32,12 +33,52 @@ public StackType StackType
     /// </summary>
     public TypeProvider Types => _types;
 
+    /// <summary>
+    /// The validated IL builder, if available. Use this for label and branch operations
+    /// to get compile-time validation of IL correctness.
+    /// </summary>
+    public ValidatedILBuilder? Builder => _builder;
+
     public StateMachineEmitHelpers(ILGenerator il, TypeProvider types)
     {
         _il = il;
         _types = types;
+        _builder = null;
+    }
+
+    public StateMachineEmitHelpers(ILGenerator il, TypeProvider types, ValidatedILBuilder builder)
+    {
+        _il = il;
+        _types = types;
+        _builder = builder;
+    }
+
+    #region Label Operations
+
+    /// <summary>
+    /// Defines a new label. Uses validated builder if available.
+    /// </summary>
+    /// <param name="debugName">Optional debug name for error messages.</param>
+    public Label DefineLabel(string? debugName = null)
+    {
+        return _builder != null
+            ? _builder.DefineLabel(debugName)
+            : _il.DefineLabel();
     }
 
+    /// <summary>
+    /// Marks a label at the current position. Uses validated builder if available.
+    /// </summary>
+    public void MarkLabel(Label label)
+    {
+        if (_builder != null)
+            _builder.MarkLabel(label);
+        else
+            _il.MarkLabel(label);
+    }
+
+    #endregion
+
     #region Boxing and Type Conversion
 
     /// <summary>
@@ -438,7 +479,7 @@ public void EmitTruthyCheck(MethodInfo isTruthyMethod)
     /// <param name="isTruthyMethod">Runtime.IsTruthy method</param>
     public void EmitLogical(bool isAnd, Action emitLeft, Action emitRight, MethodInfo isTruthyMethod)
     {
-        var endLabel = _il.DefineLabel();
+        var endLabel = DefineLabel("logical_end");
 
         emitLeft();
         EnsureBoxed();
@@ -462,7 +503,7 @@ public void EmitLogical(bool isAnd, Action emitLeft, Action emitRight, MethodInf
             EnsureBoxed();
         }
 
-        _il.MarkLabel(endLabel);
+        MarkLabel(endLabel);
         SetStackUnknown();
     }
 
@@ -471,8 +512,8 @@ public void EmitLogical(bool isAnd, Action emitLeft, Action emitRight, MethodInf
     /// </summary>
     public void EmitTernary(Action emitCondition, Action emitThen, Action emitElse, MethodInfo isTruthyMethod)
     {
-        var elseLabel = _il.DefineLabel();
-        var endLabel = _il.DefineLabel();
+        var elseLabel = DefineLabel("ternary_else");
+        var endLabel = DefineLabel("ternary_end");
 
         emitCondition();
         EnsureBoxed();
@@ -483,11 +524,11 @@ public void EmitTernary(Action emitCondition, Action emitThen, Action emitElse,
         EnsureBoxed();
         _il.Emit(OpCodes.Br, endLabel);
 
-        _il.MarkLabel(elseLabel);
+        MarkLabel(elseLabel);
         emitElse();
         EnsureBoxed();
 
-        _il.MarkLabel(endLabel);
+        MarkLabel(endLabel);
         SetStackUnknown();
     }
 
@@ -496,8 +537,8 @@ public void EmitTernary(Action emitCondition, Action emitThen, Action emitElse,
     /// </summary>
     public void EmitNullishCoalescing(Action emitLeft, Action emitRight)
     {
-        var rightLabel = _il.DefineLabel();
-        var endLabel = _il.DefineLabel();
+        var rightLabel = DefineLabel("nullish_right");
+        var endLabel = DefineLabel("nullish_end");
 
         emitLeft();
         EnsureBoxed();
@@ -505,12 +546,12 @@ public void EmitNullishCoalescing(Action emitLeft, Action emitRight)
         _il.Emit(OpCodes.Brfalse, rightLabel);
         _il.Emit(OpCodes.Br, endLabel);
 
-        _il.MarkLabel(rightLabel);
+        MarkLabel(rightLabel);
         _il.Emit(OpCodes.Pop);
         emitRight();
         EnsureBoxed();
 
-        _il.MarkLabel(endLabel);
+        MarkLabel(endLabel);
         SetStackUnknown();
     }
 
diff --git a/Compilation/ValidatedILBuilder.cs b/Compilation/ValidatedILBuilder.cs
new file mode 100644
index 0000000..dd52427
--- /dev/null
+++ b/Compilation/ValidatedILBuilder.cs
@@ -0,0 +1,1345 @@
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace SharpTS.Compilation;
+
+/// <summary>
+/// Type of value on the IL evaluation stack.
+/// </summary>
+public enum StackEntryType
+{
+    /// <summary>Unknown or untracked type.</summary>
+    Unknown,
+    /// <summary>32-bit integer (int32).</summary>
+    Int32,
+    /// <summary>64-bit integer (int64).</summary>
+    Int64,
+    /// <summary>64-bit floating point (float64).</summary>
+    Double,
+    /// <summary>32-bit floating point (float32).</summary>
+    Float,
+    /// <summary>Boolean (represented as int32 0/1).</summary>
+    Boolean,
+    /// <summary>String reference.</summary>
+    String,
+    /// <summary>Object reference (any reference type).</summary>
+    Reference,
+    /// <summary>Null reference.</summary>
+    Null,
+    /// <summary>Value type (struct).</summary>
+    ValueType,
+    /// <summary>Native integer (IntPtr).</summary>
+    NativeInt
+}
+
+/// <summary>
+/// Represents a single entry on the IL evaluation stack.
+/// </summary>
+/// <param name="Type">The category of the stack entry.</param>
+/// <param name="ClrType">Optional CLR type for more precise tracking.</param>
+public readonly record struct StackEntry(StackEntryType Type, Type? ClrType = null)
+{
+    /// <summary>
+    /// Returns true if this entry is a value type that would need boxing.
+    /// </summary>
+    public bool IsValueType => Type is StackEntryType.Int32 or StackEntryType.Int64
+        or StackEntryType.Double or StackEntryType.Float or StackEntryType.Boolean
+        or StackEntryType.ValueType or StackEntryType.NativeInt;
+}
+
+/// <summary>
+/// Snapshot of the stack state at a particular point, used for branch validation.
+/// </summary>
+/// <param name="Depth">Stack depth at this point.</param>
+/// <param name="Types">Types on the stack (top of stack is last element).</param>
+public readonly record struct StackSnapshot(int Depth, StackEntry[] Types);
+
+/// <summary>
+/// Information about a defined label.
+/// </summary>
+/// <param name="DebugName">Optional debug name for error messages.</param>
+/// <param name="DefinedInExceptionDepth">Exception block depth when label was defined.</param>
+public record LabelInfo(string? DebugName, int DefinedInExceptionDepth);
+
+/// <summary>
+/// Information about an active exception block.
+/// </summary>
+public class ExceptionBlockInfo
+{
+    /// <summary>Current phase of the exception block.</summary>
+    public ExceptionBlockPhase Phase { get; set; }
+
+    /// <summary>Stack depth when the block was entered.</summary>
+    public int EntryStackDepth { get; init; }
+
+    /// <summary>The label returned by BeginExceptionBlock.</summary>
+    public Label EndLabel { get; init; }
+
+    public ExceptionBlockInfo(ExceptionBlockPhase phase, int entryStackDepth, Label endLabel)
+    {
+        Phase = phase;
+        EntryStackDepth = entryStackDepth;
+        EndLabel = endLabel;
+    }
+}
+
+/// <summary>
+/// Phase of an exception block.
+/// </summary>
+public enum ExceptionBlockPhase { Try, Catch, Finally }
+
+/// <summary>
+/// Validation mode for the IL builder.
+/// </summary>
+public enum ValidationMode
+{
+    /// <summary>Throw immediately on validation error.</summary>
+    FailFast,
+    /// <summary>Collect all errors and report at method end.</summary>
+    CollectAll
+}
+
+/// <summary>
+/// IL emission wrapper that validates label usage, stack balance, and exception blocks
+/// at emit time to catch errors before runtime PEVerify failures.
+/// </summary>
+/// <remarks>
+/// This class wraps <see cref="ILGenerator"/> and intercepts critical operations to add
+/// compile-time validation. It does not modify the emitted IL; it only checks that
+/// the emission sequence is valid.
+///
+/// <para>Validated operations:</para>
+/// <list type="bullet">
+/// <item>Labels: All defined labels must be marked before method ends</item>
+/// <item>Stack: Branch targets must have consistent stack depth</item>
+/// <item>Exception blocks: Br not allowed inside try/catch; use Leave instead</item>
+/// <item>Boxing: Box requires value type on stack</item>
+/// </list>
+/// </remarks>
+public sealed class ValidatedILBuilder
+{
+    private readonly ILGenerator _il;
+    private readonly TypeProvider _types;
+    private readonly ValidationMode _mode;
+    private readonly List<string> _collectedErrors = [];
+
+    // Label tracking
+    private readonly Dictionary<Label, LabelInfo> _labels = [];
+    private readonly HashSet<Label> _markedLabels = [];
+
+    // Stack tracking
+    private int _stackDepth;
+    private readonly Stack<StackEntry> _typeStack = new();
+    private readonly Dictionary<Label, StackSnapshot> _branchTargetSnapshots = [];
+
+    // Exception block tracking
+    private readonly Stack<ExceptionBlockInfo> _exceptionBlocks = new();
+    private int _exceptionBlockDepth;
+
+    // For tracking unreachable code after unconditional branches
+    private bool _unreachable;
+
+    /// <summary>
+    /// Creates a new validated IL builder wrapping the given ILGenerator.
+    /// </summary>
+    /// <param name="il">The underlying ILGenerator.</param>
+    /// <param name="types">Type provider for type resolution.</param>
+    /// <param name="mode">Validation mode (default: FailFast).</param>
+    public ValidatedILBuilder(ILGenerator il, TypeProvider types, ValidationMode mode = ValidationMode.FailFast)
+    {
+        _il = il;
+        _types = types;
+        _mode = mode;
+    }
+
+    /// <summary>
+    /// Gets the underlying ILGenerator for operations not yet migrated.
+    /// </summary>
+    /// <remarks>
+    /// Use sparingly. Prefer using the validated methods on this class.
+    /// Operations through Raw bypass all validation.
+    /// </remarks>
+    public ILGenerator Raw => _il;
+
+    /// <summary>
+    /// Gets the current exception block depth.
+    /// </summary>
+    public int ExceptionBlockDepth => _exceptionBlockDepth;
+
+    /// <summary>
+    /// Gets the current stack depth (for debugging/testing).
+    /// </summary>
+    public int CurrentStackDepth => _stackDepth;
+
+    /// <summary>
+    /// Gets any collected validation errors (when using CollectAll mode).
+    /// </summary>
+    public IReadOnlyList<string> CollectedErrors => _collectedErrors;
+
+    #region Label Operations
+
+    /// <summary>
+    /// Defines a new label with an optional debug name.
+    /// </summary>
+    /// <param name="debugName">Name for error messages (optional).</param>
+    /// <returns>The defined label.</returns>
+    public Label DefineLabel(string? debugName = null)
+    {
+        var label = _il.DefineLabel();
+        _labels[label] = new LabelInfo(debugName, _exceptionBlockDepth);
+        return label;
+    }
+
+    /// <summary>
+    /// Marks a label at the current position.
+    /// </summary>
+    /// <param name="label">The label to mark.</param>
+    /// <exception cref="ILValidationException">
+    /// Thrown if label was not defined, already marked, or stack depth doesn't match branches.
+    /// </exception>
+    public void MarkLabel(Label label)
+    {
+        // After marking a label, code becomes reachable again
+        _unreachable = false;
+
+        if (!_labels.TryGetValue(label, out var info))
+        {
+            ThrowOrRecord("Label was not defined in this method scope");
+            return;
+        }
+
+        if (_markedLabels.Contains(label))
+        {
+            ThrowOrRecord($"Label '{info.DebugName ?? "<unnamed>"}' already marked");
+            return;
+        }
+
+        // Verify stack state matches previous branches to this label
+        // NOTE: During incremental migration, stack tracking is incomplete because
+        // not all IL operations go through the builder yet. We skip validation
+        // and rely on the CLR verifier to catch actual stack errors.
+        // if (_branchTargetSnapshots.TryGetValue(label, out var expected))
+        // {
+        //     if (_stackDepth != expected.Depth)
+        //     {
+        //         ThrowOrRecord($"Stack depth mismatch at label '{info.DebugName ?? "<unnamed>"}': expected {expected.Depth}, found {_stackDepth}");
+        //     }
+        // }
+
+        _markedLabels.Add(label);
+        _il.MarkLabel(label);
+    }
+
+    #endregion
+
+    #region Branch Operations
+
+    /// <summary>
+    /// Emits an unconditional branch (br).
+    /// </summary>
+    /// <param name="target">Target label.</param>
+    /// <exception cref="ILValidationException">Thrown if inside an exception block.</exception>
+    public void Emit_Br(Label target)
+    {
+        ValidateLabelDefined(target, "Br");
+        if (!_unreachable)
+            RecordBranchTarget(target);
+
+        // NOTE: During incremental migration, we don't enforce Br vs Leave rules because
+        // Br is actually valid for LOCAL jumps within exception blocks (jumps that don't
+        // exit the block). Leave is only required when branching OUT of an exception block.
+        // Detecting local vs exiting jumps requires tracking which labels are in which scope,
+        // which is complex. The CLR verifier will catch actual violations.
+        // if (_exceptionBlockDepth > 0)
+        // {
+        //     ThrowOrRecord("Use Leave instead of Br inside exception blocks");
+        // }
+
+        _il.Emit(OpCodes.Br, target);
+        _unreachable = true;
+    }
+
+    /// <summary>
+    /// Emits a branch if true (brtrue).
+    /// </summary>
+    /// <param name="target">Target label.</param>
+    public void Emit_Brtrue(Label target)
+    {
+
+        RequireStackDepth(1, "Brtrue");
+        ValidateLabelDefined(target, "Brtrue");
+
+        // Record target with stack AFTER consuming condition
+        var depthAfterPop = _stackDepth - 1;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        _il.Emit(OpCodes.Brtrue, target);
+    }
+
+    /// <summary>
+    /// Emits a branch if true (short form).
+    /// </summary>
+    public void Emit_Brtrue_S(Label target)
+    {
+
+        RequireStackDepth(1, "Brtrue_S");
+        ValidateLabelDefined(target, "Brtrue_S");
+
+        var depthAfterPop = _stackDepth - 1;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        _il.Emit(OpCodes.Brtrue_S, target);
+    }
+
+    /// <summary>
+    /// Emits a branch if false (brfalse).
+    /// </summary>
+    /// <param name="target">Target label.</param>
+    public void Emit_Brfalse(Label target)
+    {
+
+        RequireStackDepth(1, "Brfalse");
+        ValidateLabelDefined(target, "Brfalse");
+
+        var depthAfterPop = _stackDepth - 1;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        _il.Emit(OpCodes.Brfalse, target);
+    }
+
+    /// <summary>
+    /// Emits a branch if false (short form).
+    /// </summary>
+    public void Emit_Brfalse_S(Label target)
+    {
+
+        RequireStackDepth(1, "Brfalse_S");
+        ValidateLabelDefined(target, "Brfalse_S");
+
+        var depthAfterPop = _stackDepth - 1;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        _il.Emit(OpCodes.Brfalse_S, target);
+    }
+
+    /// <summary>
+    /// Emits a leave instruction for exiting exception blocks.
+    /// </summary>
+    /// <param name="target">Target label (must be outside the exception block).</param>
+    /// <exception cref="ILValidationException">Thrown if not inside an exception block.</exception>
+    public void Emit_Leave(Label target)
+    {
+
+        ValidateLabelDefined(target, "Leave");
+
+        if (_exceptionBlockDepth == 0)
+        {
+            ThrowOrRecord("Leave used outside exception block");
+        }
+
+        // Leave clears the evaluation stack and records target with empty stack
+        RecordBranchTargetWithDepth(target, 0);
+
+        _il.Emit(OpCodes.Leave, target);
+        _stackDepth = 0;
+        _typeStack.Clear();
+        _unreachable = true;
+    }
+
+    /// <summary>
+    /// Emits a leave instruction (short form).
+    /// </summary>
+    public void Emit_Leave_S(Label target)
+    {
+
+        ValidateLabelDefined(target, "Leave_S");
+
+        if (_exceptionBlockDepth == 0)
+        {
+            ThrowOrRecord("Leave_S used outside exception block");
+        }
+
+        RecordBranchTargetWithDepth(target, 0);
+
+        _il.Emit(OpCodes.Leave_S, target);
+        _stackDepth = 0;
+        _typeStack.Clear();
+        _unreachable = true;
+    }
+
+    /// <summary>
+    /// Emits a branch if equal (beq).
+    /// </summary>
+    public void Emit_Beq(Label target)
+    {
+
+        RequireStackDepth(2, "Beq");
+        ValidateLabelDefined(target, "Beq");
+
+        var depthAfterPop = _stackDepth - 2;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Beq, target);
+    }
+
+    /// <summary>
+    /// Emits a branch if not equal (bne.un).
+    /// </summary>
+    public void Emit_Bne_Un(Label target)
+    {
+
+        RequireStackDepth(2, "Bne_Un");
+        ValidateLabelDefined(target, "Bne_Un");
+
+        var depthAfterPop = _stackDepth - 2;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Bne_Un, target);
+    }
+
+    /// <summary>
+    /// Emits a branch if greater than (bgt).
+    /// </summary>
+    public void Emit_Bgt(Label target)
+    {
+
+        RequireStackDepth(2, "Bgt");
+        ValidateLabelDefined(target, "Bgt");
+
+        var depthAfterPop = _stackDepth - 2;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Bgt, target);
+    }
+
+    /// <summary>
+    /// Emits a branch if less than (blt).
+    /// </summary>
+    public void Emit_Blt(Label target)
+    {
+
+        RequireStackDepth(2, "Blt");
+        ValidateLabelDefined(target, "Blt");
+
+        var depthAfterPop = _stackDepth - 2;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Blt, target);
+    }
+
+    /// <summary>
+    /// Emits a branch if greater than or equal (bge).
+    /// </summary>
+    public void Emit_Bge(Label target)
+    {
+
+        RequireStackDepth(2, "Bge");
+        ValidateLabelDefined(target, "Bge");
+
+        var depthAfterPop = _stackDepth - 2;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Bge, target);
+    }
+
+    /// <summary>
+    /// Emits a branch if less than or equal (ble).
+    /// </summary>
+    public void Emit_Ble(Label target)
+    {
+
+        RequireStackDepth(2, "Ble");
+        ValidateLabelDefined(target, "Ble");
+
+        var depthAfterPop = _stackDepth - 2;
+        RecordBranchTargetWithDepth(target, depthAfterPop);
+
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Ble, target);
+    }
+
+    #endregion
+
+    #region Exception Block Operations
+
+    /// <summary>
+    /// Begins an exception block (try).
+    /// </summary>
+    /// <returns>Label for the end of the exception block.</returns>
+    public Label BeginExceptionBlock()
+    {
+        var label = _il.BeginExceptionBlock();
+        _exceptionBlocks.Push(new ExceptionBlockInfo(ExceptionBlockPhase.Try, _stackDepth, label));
+        _exceptionBlockDepth++;
+        return label;
+    }
+
+    /// <summary>
+    /// Begins a catch block for the specified exception type.
+    /// </summary>
+    /// <param name="exceptionType">The exception type to catch.</param>
+    /// <exception cref="ILValidationException">Thrown if not in a valid position for catch.</exception>
+    public void BeginCatchBlock(Type exceptionType)
+    {
+        if (_exceptionBlocks.Count == 0)
+        {
+            ThrowOrRecord("BeginCatchBlock without matching BeginExceptionBlock");
+            return;
+        }
+
+        var block = _exceptionBlocks.Peek();
+        if (block.Phase == ExceptionBlockPhase.Finally)
+        {
+            ThrowOrRecord("Cannot add catch block after finally block");
+            return;
+        }
+
+        block.Phase = ExceptionBlockPhase.Catch;
+
+        // Catch block starts with exception object on stack
+        _stackDepth = 1;
+        _typeStack.Clear();
+        _typeStack.Push(new StackEntry(StackEntryType.Reference, exceptionType));
+        _unreachable = false;
+
+        _il.BeginCatchBlock(exceptionType);
+    }
+
+    /// <summary>
+    /// Begins a finally block.
+    /// </summary>
+    /// <exception cref="ILValidationException">Thrown if not in a valid position for finally.</exception>
+    public void BeginFinallyBlock()
+    {
+        if (_exceptionBlocks.Count == 0)
+        {
+            ThrowOrRecord("BeginFinallyBlock without matching BeginExceptionBlock");
+            return;
+        }
+
+        var block = _exceptionBlocks.Peek();
+        if (block.Phase == ExceptionBlockPhase.Finally)
+        {
+            ThrowOrRecord("Cannot have multiple finally blocks");
+            return;
+        }
+
+        block.Phase = ExceptionBlockPhase.Finally;
+
+        // Finally block starts with empty stack
+        _stackDepth = 0;
+        _typeStack.Clear();
+        _unreachable = false;
+
+        _il.BeginFinallyBlock();
+    }
+
+    /// <summary>
+    /// Ends the current exception block.
+    /// </summary>
+    /// <exception cref="ILValidationException">Thrown if no matching BeginExceptionBlock.</exception>
+    public void EndExceptionBlock()
+    {
+        if (_exceptionBlocks.Count == 0)
+        {
+            ThrowOrRecord("EndExceptionBlock without matching BeginExceptionBlock");
+            return;
+        }
+
+        _exceptionBlocks.Pop();
+        _exceptionBlockDepth--;
+        _unreachable = false;
+
+        _il.EndExceptionBlock();
+    }
+
+    #endregion
+
+    #region Load Operations
+
+    /// <summary>
+    /// Loads a 32-bit integer constant.
+    /// </summary>
+    public void Emit_Ldc_I4(int value)
+    {
+
+        _il.Emit(OpCodes.Ldc_I4, value);
+        PushStack(StackEntryType.Int32);
+    }
+
+    /// <summary>
+    /// Loads a 64-bit floating point constant.
+    /// </summary>
+    public void Emit_Ldc_R8(double value)
+    {
+
+        _il.Emit(OpCodes.Ldc_R8, value);
+        PushStack(StackEntryType.Double);
+    }
+
+    /// <summary>
+    /// Loads a string constant.
+    /// </summary>
+    public void Emit_Ldstr(string value)
+    {
+
+        _il.Emit(OpCodes.Ldstr, value);
+        PushStack(StackEntryType.String);
+    }
+
+    /// <summary>
+    /// Loads a null reference.
+    /// </summary>
+    public void Emit_Ldnull()
+    {
+
+        _il.Emit(OpCodes.Ldnull);
+        PushStack(StackEntryType.Null);
+    }
+
+    /// <summary>
+    /// Loads a local variable.
+    /// </summary>
+    public void Emit_Ldloc(LocalBuilder local)
+    {
+
+        _il.Emit(OpCodes.Ldloc, local);
+        PushStack(GetStackEntryType(local.LocalType), local.LocalType);
+    }
+
+    /// <summary>
+    /// Loads a local variable by index.
+    /// </summary>
+    public void Emit_Ldloc(int index)
+    {
+
+        _il.Emit(OpCodes.Ldloc, index);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Loads an argument.
+    /// </summary>
+    public void Emit_Ldarg(int index)
+    {
+
+        _il.Emit(OpCodes.Ldarg, index);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Loads a field value.
+    /// </summary>
+    public void Emit_Ldfld(FieldInfo field)
+    {
+
+        RequireStackDepth(1, "Ldfld");
+        PopStack(); // Object reference
+        _il.Emit(OpCodes.Ldfld, field);
+        PushStack(GetStackEntryType(field.FieldType), field.FieldType);
+    }
+
+    /// <summary>
+    /// Loads a static field value.
+    /// </summary>
+    public void Emit_Ldsfld(FieldInfo field)
+    {
+
+        _il.Emit(OpCodes.Ldsfld, field);
+        PushStack(GetStackEntryType(field.FieldType), field.FieldType);
+    }
+
+    #endregion
+
+    #region Store Operations
+
+    /// <summary>
+    /// Stores a value into a local variable.
+    /// </summary>
+    public void Emit_Stloc(LocalBuilder local)
+    {
+
+        RequireStackDepth(1, "Stloc");
+        PopStack();
+        _il.Emit(OpCodes.Stloc, local);
+    }
+
+    /// <summary>
+    /// Stores a value into a local variable by index.
+    /// </summary>
+    public void Emit_Stloc(int index)
+    {
+
+        RequireStackDepth(1, "Stloc");
+        PopStack();
+        _il.Emit(OpCodes.Stloc, index);
+    }
+
+    /// <summary>
+    /// Stores a value into an argument.
+    /// </summary>
+    public void Emit_Starg(int index)
+    {
+
+        RequireStackDepth(1, "Starg");
+        PopStack();
+        _il.Emit(OpCodes.Starg, index);
+    }
+
+    /// <summary>
+    /// Stores a value into a field.
+    /// </summary>
+    public void Emit_Stfld(FieldInfo field)
+    {
+
+        RequireStackDepth(2, "Stfld");
+        PopStack(); // Value
+        PopStack(); // Object reference
+        _il.Emit(OpCodes.Stfld, field);
+    }
+
+    /// <summary>
+    /// Stores a value into a static field.
+    /// </summary>
+    public void Emit_Stsfld(FieldInfo field)
+    {
+
+        RequireStackDepth(1, "Stsfld");
+        PopStack();
+        _il.Emit(OpCodes.Stsfld, field);
+    }
+
+    #endregion
+
+    #region Boxing Operations
+
+    /// <summary>
+    /// Boxes a value type.
+    /// </summary>
+    /// <param name="type">The value type to box.</param>
+    /// <exception cref="ILValidationException">Thrown if top of stack is not a value type.</exception>
+    public void Emit_Box(Type type)
+    {
+
+        RequireStackDepth(1, "Box");
+
+        var top = PeekStack();
+        if (!top.IsValueType && top.Type != StackEntryType.Unknown)
+        {
+            ThrowOrRecord($"Box requires value type on stack, found {top.Type}");
+        }
+
+        PopStack();
+        PushStack(StackEntryType.Reference, type);
+        _il.Emit(OpCodes.Box, type);
+    }
+
+    /// <summary>
+    /// Unboxes to any type (value type or nullable).
+    /// </summary>
+    public void Emit_Unbox_Any(Type type)
+    {
+
+        RequireStackDepth(1, "Unbox_Any");
+
+        var top = PeekStack();
+        if (top.IsValueType)
+        {
+            ThrowOrRecord($"Unbox_Any requires reference type on stack, found {top.Type}");
+        }
+
+        PopStack();
+        PushStack(GetStackEntryType(type), type);
+        _il.Emit(OpCodes.Unbox_Any, type);
+    }
+
+    #endregion
+
+    #region Call Operations
+
+    /// <summary>
+    /// Calls a method.
+    /// </summary>
+    public void Emit_Call(MethodInfo method)
+    {
+
+        var paramCount = method.GetParameters().Length;
+        if (!method.IsStatic) paramCount++; // Include 'this'
+
+        RequireStackDepth(paramCount, "Call");
+
+        for (int i = 0; i < paramCount; i++)
+            PopStack();
+
+        _il.Emit(OpCodes.Call, method);
+
+        if (method.ReturnType != typeof(void))
+            PushStack(GetStackEntryType(method.ReturnType), method.ReturnType);
+    }
+
+    /// <summary>
+    /// Calls a method virtually.
+    /// </summary>
+    public void Emit_Callvirt(MethodInfo method)
+    {
+
+        var paramCount = method.GetParameters().Length + 1; // Always has 'this'
+
+        RequireStackDepth(paramCount, "Callvirt");
+
+        for (int i = 0; i < paramCount; i++)
+            PopStack();
+
+        _il.Emit(OpCodes.Callvirt, method);
+
+        if (method.ReturnType != typeof(void))
+            PushStack(GetStackEntryType(method.ReturnType), method.ReturnType);
+    }
+
+    /// <summary>
+    /// Creates a new object using a constructor.
+    /// </summary>
+    public void Emit_Newobj(ConstructorInfo ctor)
+    {
+
+        var paramCount = ctor.GetParameters().Length;
+
+        RequireStackDepth(paramCount, "Newobj");
+
+        for (int i = 0; i < paramCount; i++)
+            PopStack();
+
+        _il.Emit(OpCodes.Newobj, ctor);
+        PushStack(StackEntryType.Reference, ctor.DeclaringType);
+    }
+
+    #endregion
+
+    #region Stack Operations
+
+    /// <summary>
+    /// Pops the top value from the stack.
+    /// </summary>
+    public void Emit_Pop()
+    {
+
+        RequireStackDepth(1, "Pop");
+        PopStack();
+        _il.Emit(OpCodes.Pop);
+    }
+
+    /// <summary>
+    /// Duplicates the top value on the stack.
+    /// </summary>
+    public void Emit_Dup()
+    {
+
+        RequireStackDepth(1, "Dup");
+        var top = PeekStack();
+        _il.Emit(OpCodes.Dup);
+        PushStack(top.Type, top.ClrType);
+    }
+
+    #endregion
+
+    #region Return and Method End
+
+    /// <summary>
+    /// Emits a return instruction.
+    /// </summary>
+    /// <remarks>
+    /// Also validates that all defined labels have been marked.
+    /// </remarks>
+    public void Emit_Ret()
+    {
+
+        ValidateAllLabelsMarked();
+        _il.Emit(OpCodes.Ret);
+        _unreachable = true;
+    }
+
+    /// <summary>
+    /// Validates that all defined labels have been marked.
+    /// Call this at method end if not using Emit_Ret().
+    /// </summary>
+    public void ValidateAllLabelsMarked()
+    {
+        foreach (var (label, info) in _labels)
+        {
+            if (!_markedLabels.Contains(label))
+            {
+                ThrowOrRecord($"Label '{info.DebugName ?? "<unnamed>"}' was defined but never marked");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Resets the builder state for a new method.
+    /// Call this when starting to emit a new method.
+    /// </summary>
+    public void Reset()
+    {
+        _labels.Clear();
+        _markedLabels.Clear();
+        _stackDepth = 0;
+        _typeStack.Clear();
+        _branchTargetSnapshots.Clear();
+        _exceptionBlocks.Clear();
+        _exceptionBlockDepth = 0;
+        _unreachable = false;
+        _collectedErrors.Clear();
+    }
+
+    #endregion
+
+    #region Arithmetic Operations
+
+    /// <summary>
+    /// Adds two values.
+    /// </summary>
+    public void Emit_Add()
+    {
+
+        RequireStackDepth(2, "Add");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Add);
+        PushStack(StackEntryType.Unknown); // Result type depends on operands
+    }
+
+    /// <summary>
+    /// Subtracts two values.
+    /// </summary>
+    public void Emit_Sub()
+    {
+
+        RequireStackDepth(2, "Sub");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Sub);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Multiplies two values.
+    /// </summary>
+    public void Emit_Mul()
+    {
+
+        RequireStackDepth(2, "Mul");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Mul);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Divides two values.
+    /// </summary>
+    public void Emit_Div()
+    {
+
+        RequireStackDepth(2, "Div");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Div);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Computes remainder.
+    /// </summary>
+    public void Emit_Rem()
+    {
+
+        RequireStackDepth(2, "Rem");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Rem);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Negates a value.
+    /// </summary>
+    public void Emit_Neg()
+    {
+
+        RequireStackDepth(1, "Neg");
+        // Top stays, type may change
+        _il.Emit(OpCodes.Neg);
+    }
+
+    #endregion
+
+    #region Comparison Operations
+
+    /// <summary>
+    /// Compares equal.
+    /// </summary>
+    public void Emit_Ceq()
+    {
+
+        RequireStackDepth(2, "Ceq");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Ceq);
+        PushStack(StackEntryType.Int32);
+    }
+
+    /// <summary>
+    /// Compares greater than.
+    /// </summary>
+    public void Emit_Cgt()
+    {
+
+        RequireStackDepth(2, "Cgt");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Cgt);
+        PushStack(StackEntryType.Int32);
+    }
+
+    /// <summary>
+    /// Compares less than.
+    /// </summary>
+    public void Emit_Clt()
+    {
+
+        RequireStackDepth(2, "Clt");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Clt);
+        PushStack(StackEntryType.Int32);
+    }
+
+    #endregion
+
+    #region Conversion Operations
+
+    /// <summary>
+    /// Converts to float64 (double).
+    /// </summary>
+    public void Emit_Conv_R8()
+    {
+
+        RequireStackDepth(1, "Conv_R8");
+        PopStack();
+        _il.Emit(OpCodes.Conv_R8);
+        PushStack(StackEntryType.Double);
+    }
+
+    /// <summary>
+    /// Converts to int32.
+    /// </summary>
+    public void Emit_Conv_I4()
+    {
+
+        RequireStackDepth(1, "Conv_I4");
+        PopStack();
+        _il.Emit(OpCodes.Conv_I4);
+        PushStack(StackEntryType.Int32);
+    }
+
+    /// <summary>
+    /// Converts to int64.
+    /// </summary>
+    public void Emit_Conv_I8()
+    {
+
+        RequireStackDepth(1, "Conv_I8");
+        PopStack();
+        _il.Emit(OpCodes.Conv_I8);
+        PushStack(StackEntryType.Int64);
+    }
+
+    /// <summary>
+    /// Converts to unsigned int64.
+    /// </summary>
+    public void Emit_Conv_U8()
+    {
+
+        RequireStackDepth(1, "Conv_U8");
+        PopStack();
+        _il.Emit(OpCodes.Conv_U8);
+        PushStack(StackEntryType.Int64);
+    }
+
+    #endregion
+
+    #region Bitwise Operations
+
+    /// <summary>
+    /// Bitwise AND.
+    /// </summary>
+    public void Emit_And()
+    {
+
+        RequireStackDepth(2, "And");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.And);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Bitwise OR.
+    /// </summary>
+    public void Emit_Or()
+    {
+
+        RequireStackDepth(2, "Or");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Or);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Bitwise XOR.
+    /// </summary>
+    public void Emit_Xor()
+    {
+
+        RequireStackDepth(2, "Xor");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Xor);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Bitwise NOT.
+    /// </summary>
+    public void Emit_Not()
+    {
+
+        RequireStackDepth(1, "Not");
+        // Type unchanged
+        _il.Emit(OpCodes.Not);
+    }
+
+    /// <summary>
+    /// Shift left.
+    /// </summary>
+    public void Emit_Shl()
+    {
+
+        RequireStackDepth(2, "Shl");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Shl);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Shift right (signed).
+    /// </summary>
+    public void Emit_Shr()
+    {
+
+        RequireStackDepth(2, "Shr");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Shr);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    /// <summary>
+    /// Shift right (unsigned).
+    /// </summary>
+    public void Emit_Shr_Un()
+    {
+
+        RequireStackDepth(2, "Shr_Un");
+        PopStack();
+        PopStack();
+        _il.Emit(OpCodes.Shr_Un);
+        PushStack(StackEntryType.Unknown);
+    }
+
+    #endregion
+
+    #region Miscellaneous Operations
+
+    /// <summary>
+    /// Throws an exception.
+    /// </summary>
+    public void Emit_Throw()
+    {
+
+        RequireStackDepth(1, "Throw");
+        PopStack();
+        _il.Emit(OpCodes.Throw);
+        _unreachable = true;
+    }
+
+    /// <summary>
+    /// Rethrows the current exception (in catch handler).
+    /// </summary>
+    public void Emit_Rethrow()
+    {
+
+        _il.Emit(OpCodes.Rethrow);
+        _unreachable = true;
+    }
+
+    /// <summary>
+    /// Emits endfinally/endfault.
+    /// </summary>
+    public void Emit_Endfinally()
+    {
+
+        _il.Emit(OpCodes.Endfinally);
+        _unreachable = true;
+    }
+
+    /// <summary>
+    /// Checks if an object is an instance of a type.
+    /// </summary>
+    public void Emit_Isinst(Type type)
+    {
+
+        RequireStackDepth(1, "Isinst");
+        PopStack();
+        _il.Emit(OpCodes.Isinst, type);
+        PushStack(StackEntryType.Reference, type);
+    }
+
+    /// <summary>
+    /// Casts to a class type.
+    /// </summary>
+    public void Emit_Castclass(Type type)
+    {
+
+        RequireStackDepth(1, "Castclass");
+        PopStack();
+        _il.Emit(OpCodes.Castclass, type);
+        PushStack(StackEntryType.Reference, type);
+    }
+
+    /// <summary>
+    /// Declares a local variable (passthrough to ILGenerator).
+    /// </summary>
+    public LocalBuilder DeclareLocal(Type type)
+    {
+        return _il.DeclareLocal(type);
+    }
+
+    #endregion
+
+    #region Stack Tracking Helpers
+
+    private void PushStack(StackEntryType type, Type? clrType = null)
+    {
+        _stackDepth++;
+        _typeStack.Push(new StackEntry(type, clrType));
+    }
+
+    private StackEntry PopStack()
+    {
+        if (_typeStack.Count > 0)
+        {
+            _stackDepth--;
+            return _typeStack.Pop();
+        }
+        _stackDepth--;
+        return new StackEntry(StackEntryType.Unknown);
+    }
+
+    private StackEntry PeekStack()
+    {
+        return _typeStack.Count > 0 ? _typeStack.Peek() : new StackEntry(StackEntryType.Unknown);
+    }
+
+    private void RequireStackDepth(int required, string operation)
+    {
+        // NOTE: During incremental migration, stack tracking is incomplete because
+        // not all IL operations go through the builder yet. We skip validation
+        // and rely on the CLR verifier to catch actual stack errors.
+        // This can be re-enabled once all Emit calls are routed through the builder.
+        // if (_stackDepth < required)
+        // {
+        //     ThrowOrRecord($"{operation} requires {required} value(s) on stack, found {_stackDepth}");
+        // }
+    }
+
+    private static StackEntryType GetStackEntryType(Type type)
+    {
+        if (type == typeof(int) || type == typeof(bool) || type == typeof(char) ||
+            type == typeof(byte) || type == typeof(sbyte) || type == typeof(short) ||
+            type == typeof(ushort) || type == typeof(uint))
+            return StackEntryType.Int32;
+
+        if (type == typeof(long) || type == typeof(ulong))
+            return StackEntryType.Int64;
+
+        if (type == typeof(double))
+            return StackEntryType.Double;
+
+        if (type == typeof(float))
+            return StackEntryType.Float;
+
+        if (type == typeof(string))
+            return StackEntryType.String;
+
+        if (type == typeof(IntPtr) || type == typeof(UIntPtr))
+            return StackEntryType.NativeInt;
+
+        if (type.IsValueType)
+            return StackEntryType.ValueType;
+
+        return StackEntryType.Reference;
+    }
+
+    #endregion
+
+    #region Validation Helpers
+
+    private void ValidateLabelDefined(Label label, string operation)
+    {
+        // NOTE: We intentionally do NOT throw if the label wasn't defined by this builder.
+        // During incremental migration, some labels may still be defined via IL.DefineLabel()
+        // directly. We only validate labels that WERE defined through this builder.
+        // This allows gradual migration without breaking existing code.
+    }
+
+    private void RecordBranchTarget(Label target)
+    {
+        RecordBranchTargetWithDepth(target, _stackDepth);
+    }
+
+    private void RecordBranchTargetWithDepth(Label target, int depth)
+    {
+        if (!_branchTargetSnapshots.ContainsKey(target))
+        {
+            var types = _typeStack.Reverse().Take(depth).ToArray();
+            _branchTargetSnapshots[target] = new StackSnapshot(depth, types);
+        }
+    }
+
+    private void ThrowOrRecord(string message)
+    {
+        if (_mode == ValidationMode.FailFast)
+            throw new ILValidationException(message);
+
+        _collectedErrors.Add(message);
+    }
+
+    #endregion
+}