diff --git a/Compilation/AsyncGeneratorMoveNextEmitter.Statements.TryCatch.cs b/Compilation/AsyncGeneratorMoveNextEmitter.Statements.TryCatch.cs
index 1a998277..a2fa90d8 100644
--- a/Compilation/AsyncGeneratorMoveNextEmitter.Statements.TryCatch.cs
+++ b/Compilation/AsyncGeneratorMoveNextEmitter.Statements.TryCatch.cs
@@ -964,71 +964,9 @@ private static bool ContainsSuspensionInExpr(Expr expr)
         }
     }
 
-    /// <summary>
-    /// Detects return/break/continue that would transfer control out of the surrounding try
-    /// region. Over-approximates conservatively (labeled break/continue are always treated as
-    /// escaping): a false positive only costs a statement some mini-segment exception coverage,
-    /// whereas a false negative would emit a `br`/`ret` inside a protected region (illegal IL).
-    /// Nested function/arrow bodies are not traversed (their returns are their own).
-    /// </summary>
-    private static bool ContainsEscapingExit(Stmt stmt, bool insideLoop, bool insideSwitch)
-    {
-        switch (stmt)
-        {
-            case Stmt.Return:
-                return true;
-            case Stmt.Break b:
-                return b.Label != null || !(insideLoop || insideSwitch);
-            case Stmt.Continue c:
-                return c.Label != null || !insideLoop;
-            case Stmt.If i:
-                return ContainsEscapingExit(i.ThenBranch, insideLoop, insideSwitch)
-                    || (i.ElseBranch != null && ContainsEscapingExit(i.ElseBranch, insideLoop, insideSwitch));
-            case Stmt.Block b:
-                if (b.Statements == null) return false;
-                foreach (var s in b.Statements)
-                    if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
-                return false;
-            case Stmt.Sequence seq:
-                foreach (var s in seq.Statements)
-                    if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
-                return false;
-            case Stmt.While w:
-                return ContainsEscapingExit(w.Body, insideLoop: true, insideSwitch);
-            case Stmt.DoWhile dw:
-                return ContainsEscapingExit(dw.Body, insideLoop: true, insideSwitch);
-            case Stmt.For f:
-                return ContainsEscapingExit(f.Body, insideLoop: true, insideSwitch);
-            case Stmt.ForOf fo:
-                return ContainsEscapingExit(fo.Body, insideLoop: true, insideSwitch);
-            case Stmt.ForIn fi:
-                return ContainsEscapingExit(fi.Body, insideLoop: true, insideSwitch);
-            case Stmt.Switch s:
-                foreach (var c in s.Cases)
-                    foreach (var cs in c.Body)
-                        if (ContainsEscapingExit(cs, insideLoop, insideSwitch: true)) return true;
-                if (s.DefaultBody != null)
-                    foreach (var ds in s.DefaultBody)
-                        if (ContainsEscapingExit(ds, insideLoop, insideSwitch: true)) return true;
-                return false;
-            case Stmt.LabeledStatement ls:
-                return ContainsEscapingExit(ls.Statement, insideLoop, insideSwitch);
-            case Stmt.TryCatch t:
-                if (ContainsEscapingExit2(t.TryBlock, insideLoop, insideSwitch)) return true;
-                if (t.CatchBlock != null && ContainsEscapingExit2(t.CatchBlock, insideLoop, insideSwitch)) return true;
-                if (t.FinallyBlock != null && ContainsEscapingExit2(t.FinallyBlock, insideLoop, insideSwitch)) return true;
-                return false;
-            default:
-                return false;
-        }
-    }
-
-    private static bool ContainsEscapingExit2(List<Stmt> statements, bool insideLoop, bool insideSwitch)
-    {
-        foreach (var s in statements)
-            if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
-        return false;
-    }
+    // ContainsEscapingExit / ContainsEscapingExit2 are shared across the suspension-aware emitters and
+    // live in StatementEmitterBase (the generator, async-generator, and async-function emitters all
+    // segment a flag-based try body around non-local exits using the same conservative analysis).
 
     #endregion
 }
diff --git a/Compilation/AsyncMoveNextEmitter.Statements.ControlFlow.cs b/Compilation/AsyncMoveNextEmitter.Statements.ControlFlow.cs
index fbe2affa..8646bba5 100644
--- a/Compilation/AsyncMoveNextEmitter.Statements.ControlFlow.cs
+++ b/Compilation/AsyncMoveNextEmitter.Statements.ControlFlow.cs
@@ -39,5 +39,22 @@ protected override void EmitReturn(Stmt.Return r)
         _il.Emit(OpCodes.Leave, _setResultLabel);
     }
 
+    /// <summary>
+    /// Branch out to <paramref name="target"/> (a loop's break/continue label). Inside a real IL
+    /// exception block a <c>br</c> out is illegal IL (BranchOutOfTry), so use <c>Leave</c> — which exits
+    /// the block legally and runs its (no-await) finally. <c>ExceptionBlockDepth</c> counts only real
+    /// blocks opened by <see cref="EmitSimpleTryCatch"/>, not the flag-based path's mini try/catch
+    /// segments (EmitSegmentInTry), so an escaping break/continue in a try-with-awaits is pulled out as a
+    /// segment-breaker (emitted at the top level, depth 0 → <c>Br</c>) while a break targeting a loop
+    /// nested inside a segment stays a legal in-segment <c>Br</c>. Mirrors the generator emitters (#727).
+    /// </summary>
+    protected override void EmitBranchToLabel(Label target)
+    {
+        if (_ctx!.ExceptionBlockDepth > 0)
+            _il.Emit(OpCodes.Leave, target);
+        else
+            _il.Emit(OpCodes.Br, target);
+    }
+
     // EmitIf: inherited from StatementEmitterBase (identical logic)
 }
diff --git a/Compilation/AsyncMoveNextEmitter.Statements.LabeledLoops.cs b/Compilation/AsyncMoveNextEmitter.Statements.LabeledLoops.cs
index 54de9271..52eeb405 100644
--- a/Compilation/AsyncMoveNextEmitter.Statements.LabeledLoops.cs
+++ b/Compilation/AsyncMoveNextEmitter.Statements.LabeledLoops.cs
@@ -113,6 +113,17 @@ private void EmitLabeledWhile(IReadOnlyList<string> labelNames, Stmt.While w, La
 
     private void EmitLabeledForOf(IReadOnlyList<string> labelNames, Stmt.ForOf f, Label outerBreakLabel)
     {
+        if (f.IsAsync)
+        {
+            // for await: route to the suspending async-iterator lowering, carrying the chain's labels so
+            // `break`/`continue <label>` target this loop. Its natural end falls through to
+            // outerBreakLabel (marked right after by EmitLabeledStatement), so an early break runs the
+            // iterator's return() cleanup, then exits. The previous synchronous enumeration here ignored
+            // f.IsAsync and left the reserved await-state labels unmarked → compile failure (#728).
+            EmitForAwaitOf(f, labelNames);
+            return;
+        }
+
         string varName = f.Variable.Lexeme;
         var varField = _builder.GetVariableField(varName);
 
diff --git a/Compilation/AsyncMoveNextEmitter.Statements.Loops.cs b/Compilation/AsyncMoveNextEmitter.Statements.Loops.cs
index 13018d51..a7e0473c 100644
--- a/Compilation/AsyncMoveNextEmitter.Statements.Loops.cs
+++ b/Compilation/AsyncMoveNextEmitter.Statements.Loops.cs
@@ -33,7 +33,16 @@ protected override void EmitForOf(Stmt.ForOf f)
     /// suspension state for each await (AsyncStateAnalyzer.VisitForOf), consumed below in the same order.
     /// The base lowering still serves async arrows and async generators (the latter tracked by #697).
     /// </summary>
-    protected override void EmitForAwaitOf(Stmt.ForOf f)
+    protected override void EmitForAwaitOf(Stmt.ForOf f) => EmitForAwaitOf(f, labelNames: null);
+
+    /// <summary>
+    /// Emits a <c>for await…of</c> loop, optionally carrying the wrapping statement labels
+    /// <paramref name="labelNames"/> (a chain <c>a: b: for await</c> contributes several) so a labeled
+    /// <c>break</c>/<c>continue &lt;label&gt;</c> targets it. The labeled path delegates here so it gets the
+    /// same suspending async-iterator lowering as the unlabeled case, rather than enumerating the async
+    /// iterator synchronously and leaving the reserved await-state labels unmarked — #728.
+    /// </summary>
+    private void EmitForAwaitOf(Stmt.ForOf f, IReadOnlyList<string>? labelNames)
     {
         // for await…of drives an async iterator: resolve it (Symbol.asyncIterator, else assume the
         // value is itself an async iterator / $IAsyncGenerator), then each iteration await
@@ -122,7 +131,13 @@ void EmitPrelude()
         var continueLabel = _il.DefineLabel();
 
         // break → cleanup (await iterator.return()); natural done → endLabel (no return() per spec).
-        EnterLoop(cleanupLabel, continueLabel);
+        // The chain's labels (when present) let `break`/`continue <label>` resolve to this loop; each is
+        // registered as its own scope at the same targets (the #704 multi-label convention).
+        bool labeled = labelNames is { Count: > 0 };
+        if (labeled)
+            EnterLabeledLoop(cleanupLabel, continueLabel, labelNames!);
+        else
+            EnterLoop(cleanupLabel, continueLabel);
 
         _il.MarkLabel(startLabel);
 
@@ -174,7 +189,10 @@ void EmitPrelude()
         _il.Emit(OpCodes.Pop);
 
         _il.MarkLabel(endLabel);
-        ExitLoop();
+        if (labeled)
+            ExitLabeledLoop(labelNames!);
+        else
+            ExitLoop();
     }
 
     /// <summary>
diff --git a/Compilation/AsyncMoveNextEmitter.Statements.TryCatch.cs b/Compilation/AsyncMoveNextEmitter.Statements.TryCatch.cs
index 4cab499b..db49796f 100644
--- a/Compilation/AsyncMoveNextEmitter.Statements.TryCatch.cs
+++ b/Compilation/AsyncMoveNextEmitter.Statements.TryCatch.cs
@@ -27,6 +27,13 @@ protected override void EmitTryCatch(Stmt.TryCatch t)
 
     private void EmitSimpleTryCatch(Stmt.TryCatch t)
     {
+        // A real IL protected region is open across the whole try/catch/finally. A `br`/`ret` directly
+        // out of it is illegal, so a non-local break/continue crossing it must use `Leave` instead —
+        // which also runs this (no-await) finally. ExceptionBlockDepth drives the Leave-vs-Br choice in
+        // EmitBranchToLabel; it is incremented only here (not in the flag path's mini try/catch
+        // segments), so a break targeting a loop nested inside the try stays a legal in-region `Br`
+        // while an escaping break/continue leaves via `Leave` (#727).
+        _ctx!.ExceptionBlockDepth++;
         _il.BeginExceptionBlock();
 
         // Emit try block statements
@@ -68,6 +75,7 @@ private void EmitSimpleTryCatch(Stmt.TryCatch t)
         }
 
         _il.EndExceptionBlock();
+        _ctx!.ExceptionBlockDepth--;
     }
 
     private void EmitTryCatchWithAwaits(Stmt.TryCatch t, bool hasAwaitsInTry, bool hasAwaitsInCatch, bool hasAwaitsInFinally)
@@ -276,53 +284,52 @@ private void EmitTryBodyWithAwaits(List<Stmt> tryBody, LocalBuilder caughtExcept
         _currentTryCatchExceptionLocal = caughtExceptionLocal;
         _currentTryCatchSkipLabel = afterTryLabel;
 
-        List<Stmt> stmtsBeforeAwait = [];
+        List<Stmt> syncSegment = [];
+
+        void FlushSegment()
+        {
+            if (syncSegment.Count == 0)
+                return;
+            // Skip the segment if an earlier one already threw (its exception heads to the catch).
+            var skipSegmentLabel = _il.DefineLabel();
+            _il.Emit(OpCodes.Ldloc, caughtExceptionLocal);
+            _il.Emit(OpCodes.Brtrue, skipSegmentLabel);
+            EmitSegmentInTry(syncSegment, caughtExceptionLocal);
+            _il.MarkLabel(skipSegmentLabel);
+            syncSegment.Clear();
+        }
 
         foreach (var stmt in tryBody)
         {
-            if (ContainsAwait([stmt]))
+            // A "segment breaker" must be emitted at the top level rather than inside a mini IL
+            // try/catch: a suspension point (await) whose resume label can't be branched into a
+            // protected region, or a non-local exit (break/continue/return) whose `Br`/`Leave` out of
+            // the try targets the enclosing loop — both illegal inside the segment's real IL block. An
+            // escaping break/continue branches with `Br` at this top level (ExceptionBlockDepth is 0),
+            // which is what makes it legal; previously it landed inside a segment and `Br`'d out of the
+            // mini try (BranchOutOfTry → invalid IL) (#727).
+            if (ContainsAwait([stmt]) || ContainsEscapingExit(stmt, insideLoop: false, insideSwitch: false))
             {
-                // Emit accumulated statements in a try block
-                if (stmtsBeforeAwait.Count > 0)
-                {
-                    // Check if exception was already caught
-                    var skipSegmentLabel = _il.DefineLabel();
-                    _il.Emit(OpCodes.Ldloc, caughtExceptionLocal);
-                    _il.Emit(OpCodes.Brtrue, skipSegmentLabel);
-
-                    EmitSegmentInTry(stmtsBeforeAwait, caughtExceptionLocal);
-                    _il.MarkLabel(skipSegmentLabel);
-                    stmtsBeforeAwait.Clear();
-                }
-
-                // Check if exception was caught before continuing with await
-                var skipAwaitLabel = _il.DefineLabel();
+                FlushSegment();
+
+                // If an earlier segment threw, skip this suspension/exit and fall through to the catch.
+                var skipLabel = _il.DefineLabel();
                 _il.Emit(OpCodes.Ldloc, caughtExceptionLocal);
-                _il.Emit(OpCodes.Brtrue, skipAwaitLabel);
+                _il.Emit(OpCodes.Brtrue, skipLabel);
 
-                // Emit the statement containing await
-                // EmitAwait will check _currentTryCatchExceptionLocal and wrap GetResult in try/catch
+                // EmitAwait checks _currentTryCatchExceptionLocal and wraps GetResult in try/catch; a
+                // break/continue/return emits its jump here, outside any real IL exception block.
                 EmitStatement(stmt);
 
-                _il.MarkLabel(skipAwaitLabel);
+                _il.MarkLabel(skipLabel);
             }
             else
             {
-                stmtsBeforeAwait.Add(stmt);
+                syncSegment.Add(stmt);
             }
         }
 
-        // Emit remaining statements in a try block
-        if (stmtsBeforeAwait.Count > 0)
-        {
-            // Check if exception was already caught
-            var skipLabel = _il.DefineLabel();
-            _il.Emit(OpCodes.Ldloc, caughtExceptionLocal);
-            _il.Emit(OpCodes.Brtrue, skipLabel);
-
-            EmitSegmentInTry(stmtsBeforeAwait, caughtExceptionLocal);
-            _il.MarkLabel(skipLabel);
-        }
+        FlushSegment();
 
         _il.MarkLabel(afterTryLabel);
 
diff --git a/Compilation/GeneratorMoveNextEmitter.Statements.TryCatch.cs b/Compilation/GeneratorMoveNextEmitter.Statements.TryCatch.cs
index cf95c857..e20a3973 100644
--- a/Compilation/GeneratorMoveNextEmitter.Statements.TryCatch.cs
+++ b/Compilation/GeneratorMoveNextEmitter.Statements.TryCatch.cs
@@ -1101,71 +1101,9 @@ private static bool ContainsYieldInExpr(Expr expr)
         }
     }
 
-    /// <summary>
-    /// Detects return/break/continue that would transfer control out of the surrounding try
-    /// region. Over-approximates conservatively (labeled break/continue are always treated as
-    /// escaping): a false positive only costs a statement some mini-segment exception coverage,
-    /// whereas a false negative would emit a `br`/`ret` inside a protected region (illegal IL).
-    /// Nested function/arrow bodies are not traversed (their returns are their own).
-    /// </summary>
-    private static bool ContainsEscapingExit(Stmt stmt, bool insideLoop, bool insideSwitch)
-    {
-        switch (stmt)
-        {
-            case Stmt.Return:
-                return true;
-            case Stmt.Break b:
-                return b.Label != null || !(insideLoop || insideSwitch);
-            case Stmt.Continue c:
-                return c.Label != null || !insideLoop;
-            case Stmt.If i:
-                return ContainsEscapingExit(i.ThenBranch, insideLoop, insideSwitch)
-                    || (i.ElseBranch != null && ContainsEscapingExit(i.ElseBranch, insideLoop, insideSwitch));
-            case Stmt.Block b:
-                if (b.Statements == null) return false;
-                foreach (var s in b.Statements)
-                    if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
-                return false;
-            case Stmt.Sequence seq:
-                foreach (var s in seq.Statements)
-                    if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
-                return false;
-            case Stmt.While w:
-                return ContainsEscapingExit(w.Body, insideLoop: true, insideSwitch);
-            case Stmt.DoWhile dw:
-                return ContainsEscapingExit(dw.Body, insideLoop: true, insideSwitch);
-            case Stmt.For f:
-                return ContainsEscapingExit(f.Body, insideLoop: true, insideSwitch);
-            case Stmt.ForOf fo:
-                return ContainsEscapingExit(fo.Body, insideLoop: true, insideSwitch);
-            case Stmt.ForIn fi:
-                return ContainsEscapingExit(fi.Body, insideLoop: true, insideSwitch);
-            case Stmt.Switch s:
-                foreach (var c in s.Cases)
-                    foreach (var cs in c.Body)
-                        if (ContainsEscapingExit(cs, insideLoop, insideSwitch: true)) return true;
-                if (s.DefaultBody != null)
-                    foreach (var ds in s.DefaultBody)
-                        if (ContainsEscapingExit(ds, insideLoop, insideSwitch: true)) return true;
-                return false;
-            case Stmt.LabeledStatement ls:
-                return ContainsEscapingExit(ls.Statement, insideLoop, insideSwitch);
-            case Stmt.TryCatch t:
-                if (ContainsEscapingExit2(t.TryBlock, insideLoop, insideSwitch)) return true;
-                if (t.CatchBlock != null && ContainsEscapingExit2(t.CatchBlock, insideLoop, insideSwitch)) return true;
-                if (t.FinallyBlock != null && ContainsEscapingExit2(t.FinallyBlock, insideLoop, insideSwitch)) return true;
-                return false;
-            default:
-                return false;
-        }
-    }
-
-    private static bool ContainsEscapingExit2(List<Stmt> statements, bool insideLoop, bool insideSwitch)
-    {
-        foreach (var s in statements)
-            if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
-        return false;
-    }
+    // ContainsEscapingExit / ContainsEscapingExit2 are shared across the suspension-aware emitters and
+    // live in StatementEmitterBase (the generator, async-generator, and async-function emitters all
+    // segment a flag-based try body around non-local exits using the same conservative analysis).
 
     #endregion
 }
diff --git a/Compilation/ILCompiler.Async.cs b/Compilation/ILCompiler.Async.cs
index 6ecdafeb..594dfd71 100644
--- a/Compilation/ILCompiler.Async.cs
+++ b/Compilation/ILCompiler.Async.cs
@@ -906,7 +906,8 @@ private void EmitAsyncStubMethod(
         }
     }
 
-    private void EmitAsyncMethodBody(MethodBuilder methodBuilder, Stmt.Function method, FieldInfo fieldsField)
+    private void EmitAsyncMethodBody(MethodBuilder methodBuilder, Stmt.Function method, FieldInfo? fieldsField,
+        bool isInstanceMethod = true, string? currentClassName = null)
     {
         // Analyze async function to determine await points and hoisted variables
         var analysis = _async.Analyzer.Analyze(method);
@@ -914,35 +915,46 @@ private void EmitAsyncMethodBody(MethodBuilder methodBuilder, Stmt.Function meth
         // Check if method has @lock decorator
         bool hasLock = HasLockDecorator(method);
 
-        // Build state machine type
+        // Build state machine type. Use the MethodBuilder's (mangled) name, not method.Name.Lexeme: a
+        // private method's lexeme is `#p`, whose `#` would land in the generated state-machine type name.
         var smBuilder = new AsyncStateMachineBuilder(_moduleBuilder, _types, _async.StateMachineCounter++);
         var hasAsyncArrows = analysis.AsyncArrows.Count > 0;
         smBuilder.DefineStateMachine(
-            $"{methodBuilder.DeclaringType!.Name}_{method.Name.Lexeme}",
+            $"{methodBuilder.DeclaringType!.Name}_{methodBuilder.Name}",
             analysis,
             _types.Object,
-            isInstanceMethod: true,  // This is an instance method
+            isInstanceMethod: isInstanceMethod,
             hasAsyncArrows: hasAsyncArrows,
             hasLock: hasLock
         );
 
         // #682: a direct-child async arrow that WRITES a captured method-local must mutate it through
         // a reference-type function display class, not the boxed value-type state machine (unverifiable
-        // unbox → readonly pointer). Async instance methods have no function-DC by default; wire one.
+        // unbox → readonly pointer). Async methods have no function-DC by default; wire one. The
+        // "::static::" infix keeps a static method's key distinct from an instance member of the same name.
+        string dcInfix = isInstanceMethod ? "::" : "::static::";
         string methodDCKey = SetupAsyncMethodFunctionDC(
-            smBuilder, $"{methodBuilder.DeclaringType!.Name}::{method.Name.Lexeme}", analysis);
+            smBuilder, $"{methodBuilder.DeclaringType!.Name}{dcInfix}{methodBuilder.Name}", analysis);
 
         // Build state machines for any async arrows found in this method
         DefineAsyncArrowStateMachines(analysis.AsyncArrows, smBuilder);
 
-        // Get lock fields if @lock decorator is present
+        // Get lock fields if @lock decorator is present (instance vs static field sets)
         FieldBuilder? asyncLockField = null;
         FieldBuilder? lockReentrancyField = null;
         if (hasLock)
         {
             var className = methodBuilder.DeclaringType!.Name;
-            _locks.AsyncLockFields.TryGetValue(className, out asyncLockField);
-            _locks.ReentrancyFields.TryGetValue(className, out lockReentrancyField);
+            if (isInstanceMethod)
+            {
+                _locks.AsyncLockFields.TryGetValue(className, out asyncLockField);
+                _locks.ReentrancyFields.TryGetValue(className, out lockReentrancyField);
+            }
+            else
+            {
+                _locks.StaticAsyncLockFields.TryGetValue(className, out asyncLockField);
+                _locks.StaticReentrancyFields.TryGetValue(className, out lockReentrancyField);
+            }
         }
 
         // Emit stub method body (creates state machine and starts it)
@@ -950,7 +962,7 @@ private void EmitAsyncMethodBody(MethodBuilder methodBuilder, Stmt.Function meth
             methodBuilder,
             smBuilder,
             method.Parameters,
-            isInstanceMethod: true,
+            isInstanceMethod: isInstanceMethod,
             asyncLockField,
             lockReentrancyField,
             functionDCKey: methodDCKey);
@@ -960,7 +972,7 @@ private void EmitAsyncMethodBody(MethodBuilder methodBuilder, Stmt.Function meth
         var ctx = new CompilationContext(il, _typeMapper, _functions.Builders, _classes.Builders, _namespaceFields, _namespaceVarFields, _types)
         {
             FieldsField = fieldsField,
-            IsInstanceMethod = true,
+            IsInstanceMethod = isInstanceMethod,
             ClosureAnalyzer = _closures.Analyzer,
             ArrowMethods = _closures.ArrowMethods,
             ConstArrowBindings = _closures.ConstArrowBindings,
@@ -1003,8 +1015,10 @@ private void EmitAsyncMethodBody(MethodBuilder methodBuilder, Stmt.Function meth
                 ImportedNames = _importedNames,
             ClassExprBuilders = _classExprs.Builders,
             IsStrictMode = _isStrictMode,
-            // ES2022 Private Class Elements support for async methods
-            CurrentClassName = methodBuilder.DeclaringType?.Name,
+            // ES2022 Private Class Elements support for async methods. currentClassName lets a private
+            // method pass its QUALIFIED class name (the ClassRegistry keys private members by it), so
+            // nested private member access inside the async body resolves under module compilation.
+            CurrentClassName = currentClassName ?? methodBuilder.DeclaringType?.Name,
             CurrentClassBuilder = methodBuilder.DeclaringType as TypeBuilder,
             // Registry services
             ClassRegistry = GetClassRegistry(),
@@ -1071,6 +1085,18 @@ private void DefineTopLevelAsyncArrows()
                 continue;
             }
 
+            // #721: an async arrow whose enclosing async function/method builds an async state machine
+            // is given its real (nested) builder by that machine's phase-6 emission — but only AFTER
+            // this earlier pass runs. Free async functions register their arrows before this pass (the
+            // ContainsKey check above already skips those); class async methods do not, so a standalone
+            // builder defined here would be a dead, never-invoked duplicate of the nested one. Skip an
+            // arrow that an enclosing async state machine will claim; an arrow behind a sync arrow/method,
+            // or a genuinely top-level one, is not claimed and still needs the standalone builder.
+            if (IsClaimedByEnclosingAsyncStateMachine(arrow))
+            {
+                continue;
+            }
+
             // Analyze this arrow for await points and hoisted locals
             var arrowAnalysis = AnalyzeAsyncArrow(arrow);
 
@@ -1097,6 +1123,26 @@ private void DefineTopLevelAsyncArrows()
         }
     }
 
+    /// <summary>
+    /// True when <paramref name="arrow"/> will be given a nested async state machine by an enclosing
+    /// async function/method's phase-6 emission (<see cref="DefineAsyncArrowStateMachines"/>), so this
+    /// pass must not also create a standalone (dead-duplicate) builder for it (#721). An async function's
+    /// state machine claims its async arrow descendants reachable through a chain of <em>async</em>
+    /// arrows; a sync arrow (or sync function) on the way up breaks that chain — arrows behind one get
+    /// their own standalone builder instead. Walks the enclosing-callable chain to decide.
+    /// </summary>
+    private bool IsClaimedByEnclosingAsyncStateMachine(Expr.ArrowFunction arrow)
+    {
+        object? enclosing = _arrowEnclosingCallable.GetValueOrDefault(arrow);
+        while (enclosing is Expr.ArrowFunction parentArrow)
+        {
+            if (!parentArrow.IsAsync)
+                return false; // a sync arrow does not build a state machine to claim descendants
+            enclosing = _arrowEnclosingCallable.GetValueOrDefault(parentArrow);
+        }
+        return enclosing is Stmt.Function { IsAsync: true };
+    }
+
     /// <summary>
     /// Emits MoveNext bodies for top-level async arrows.
     /// </summary>
diff --git a/Compilation/ILCompiler.AsyncGenerators.cs b/Compilation/ILCompiler.AsyncGenerators.cs
index 092f8ae6..f009dd5d 100644
--- a/Compilation/ILCompiler.AsyncGenerators.cs
+++ b/Compilation/ILCompiler.AsyncGenerators.cs
@@ -178,15 +178,17 @@ private void EmitAsyncGeneratorMoveNextAsyncBody(AsyncGeneratorStateMachineBuild
     /// Emits the body of an instance async generator method using a state machine.
     /// Called for class methods marked with both IsAsync and IsGenerator = true.
     /// </summary>
-    private void EmitAsyncGeneratorMethodBody(MethodBuilder methodBuilder, Stmt.Function method, FieldInfo fieldsField)
+    private void EmitAsyncGeneratorMethodBody(MethodBuilder methodBuilder, Stmt.Function method, FieldInfo fieldsField,
+        string? currentClassName = null)
     {
         // Analyze async generator function to determine yield/await points and hoisted variables
         var analysis = _asyncGenerators.Analyzer.Analyze(method);
 
-        // Build state machine type for instance method
+        // Build state machine type for instance method. Use the MethodBuilder's (mangled) name rather
+        // than method.Name.Lexeme so a private async generator's `#p` lexeme doesn't put a `#` in the name.
         var smBuilder = new AsyncGeneratorStateMachineBuilder(_moduleBuilder, _types, _asyncGenerators.StateMachineCounter++);
         smBuilder.DefineStateMachine(
-            $"{methodBuilder.DeclaringType!.Name}_{method.Name.Lexeme}",
+            $"{methodBuilder.DeclaringType!.Name}_{methodBuilder.Name}",
             analysis,
             isInstanceMethod: true,  // This is an instance method
             runtime: _runtime
@@ -232,8 +234,9 @@ private void EmitAsyncGeneratorMethodBody(MethodBuilder methodBuilder, Stmt.Func
             ImportedNames = _importedNames,
             ClassExprBuilders = _classExprs.Builders,
             IsStrictMode = _isStrictMode || CheckForUseStrict(method.Body),
-            // ES2022 Private Class Elements support for async generator methods
-            CurrentClassName = methodBuilder.DeclaringType?.Name,
+            // ES2022 Private Class Elements support for async generator methods (a private async
+            // generator threads its QUALIFIED class name so nested private member access resolves — #720).
+            CurrentClassName = currentClassName ?? methodBuilder.DeclaringType?.Name,
             CurrentClassBuilder = methodBuilder.DeclaringType as TypeBuilder,
             // Registry services
             ClassRegistry = GetClassRegistry(),
@@ -274,13 +277,11 @@ private void EmitAsyncGeneratorInstanceStubMethod(
             il.Emit(OpCodes.Stfld, smBuilder.ThisField);
         }
 
-        // Get the typed parameter types for the method
-        // We need to box value types since state machine fields are object-typed
-        string? className = methodBuilder.DeclaringType?.Name;
-        string methodName = methodBuilder.Name;
-        Type[] paramTypes = className != null
-            ? ParameterTypeResolver.ResolveMethodParameters(className, methodName, parameters, _typeMapper, _typeMap)
-            : parameters.Select(_ => typeof(object)).ToArray();
+        // Box value types since state machine fields are object-typed. Decide from the method's ACTUAL
+        // IL signature (methodBuilder.GetParameters()), not the AST-resolved types: a private method's
+        // parameters are all `object` slots, so boxing the AST-resolved value type would mismatch the
+        // `object` argument actually loaded (StackUnexpected). Mirrors EmitAsyncStubMethod.
+        var paramTypes = methodBuilder.GetParameters();
 
         // Copy parameters to state machine fields (instance methods start params at index 1)
         for (int i = 0; i < parameters.Count; i++)
@@ -292,10 +293,9 @@ private void EmitAsyncGeneratorInstanceStubMethod(
                 il.Emit(OpCodes.Dup);  // Keep state machine reference on stack
                 il.Emit(OpCodes.Ldarg, i + 1);  // +1 because 'this' is at index 0
 
-                // Box value types since state machine fields are object-typed
-                if (i < paramTypes.Length && paramTypes[i].IsValueType)
+                if (i < paramTypes.Length && paramTypes[i].ParameterType.IsValueType)
                 {
-                    il.Emit(OpCodes.Box, paramTypes[i]);
+                    il.Emit(OpCodes.Box, paramTypes[i].ParameterType);
                 }
 
                 il.Emit(OpCodes.Stfld, field);
diff --git a/Compilation/ILCompiler.Classes.Methods.cs b/Compilation/ILCompiler.Classes.Methods.cs
index 06420c39..d7683343 100644
--- a/Compilation/ILCompiler.Classes.Methods.cs
+++ b/Compilation/ILCompiler.Classes.Methods.cs
@@ -754,6 +754,40 @@ private void EmitPrivateMethodBody(
         // pads omitted optional args with the `undefined` sentinel on the value-call path.
         MarkPadsUndefined(methodBuilder);
 
+        // #720: async/generator private methods must be emitted through a state machine, exactly like
+        // their public counterparts — not linearly into __private_<name>, which leaves a bare object on
+        // the stack for an `async` method declared to return Task<object> (invalid IL) and rejects
+        // `yield` ("Yield not supported"). Route by method kind; the parameter-default prologue moves
+        // into the state machine's entry (the state-machine emitters apply EmitDefaultParameters
+        // themselves). The qualified class name is threaded so nested private member access resolves.
+        if (method.IsAsync && method.IsGenerator)
+        {
+            // Static async generators are not yet supported (the async-generator state machine is
+            // instance-only; the public static form fails the same way, #761): fall through to the
+            // linear path, which reports the existing "Yield not supported" error rather than invalid IL.
+            if (!isStatic)
+            {
+                EmitAsyncGeneratorMethodBody(methodBuilder, method, fieldsField, currentClassName: qualifiedClassName);
+                return;
+            }
+        }
+        else if (method.IsAsync)
+        {
+            EmitAsyncMethodBody(methodBuilder, method, isStatic ? null : fieldsField,
+                isInstanceMethod: !isStatic, currentClassName: qualifiedClassName);
+            return;
+        }
+        else if (method.IsGenerator)
+        {
+            // Instance and static (static generator support landed in #692) both route through the
+            // generator state machine; static uses no `this`/fields slot.
+            EmitGeneratorMethodBody(methodBuilder, method, isStatic ? null : fieldsField,
+                isInstanceMethod: !isStatic, currentClassName: qualifiedClassName);
+            return;
+        }
+        // A static async generator falls through to the linear emission below, which reports
+        // "Yield not supported" (the public static async-generator gap, #761), not invalid IL.
+
         var il = methodBuilder.GetILGenerator();
         var ctx = new CompilationContext(il, _typeMapper, _functions.Builders, _classes.Builders, _namespaceFields, _namespaceVarFields, _types)
         {
diff --git a/Compilation/ILCompiler.Classes.cs b/Compilation/ILCompiler.Classes.cs
index 0ba24959..e9cd809c 100644
--- a/Compilation/ILCompiler.Classes.cs
+++ b/Compilation/ILCompiler.Classes.cs
@@ -443,7 +443,7 @@ private void DefinePrivateClassElements(
                 methodName = methodName[1..];
 
             var paramTypes = method.Parameters.Select(_ => typeof(object)).ToArray();
-            Type returnType = method.IsAsync ? _types.TaskOfObject : typeof(object);
+            Type returnType = ResolvePrivateMethodReturnType(method, isStatic: false);
 
             // Use Assembly (internal) visibility so nested async/generator state machines can access this method
             var methodBuilder = typeBuilder.DefineMethod(
@@ -463,7 +463,7 @@ private void DefinePrivateClassElements(
                 methodName = methodName[1..];
 
             var paramTypes = method.Parameters.Select(_ => typeof(object)).ToArray();
-            Type returnType = method.IsAsync ? _types.TaskOfObject : typeof(object);
+            Type returnType = ResolvePrivateMethodReturnType(method, isStatic: true);
 
             // Use Assembly (internal) visibility so nested async/generator state machines can access this method
             var methodBuilder = typeBuilder.DefineMethod(
@@ -476,6 +476,27 @@ private void DefinePrivateClassElements(
         }
     }
 
+    /// <summary>
+    /// Return type for a private (ES2022 <c>#</c>) method's MethodBuilder, matching the state machine its
+    /// body is emitted through (see <see cref="EmitPrivateMethodBody"/>): a real <c>Task&lt;object&gt;</c>
+    /// for <c>async</c>, <c>IEnumerable&lt;object&gt;</c> for a generator (instance or static, since static
+    /// generator support landed in #692), <c>IAsyncEnumerable&lt;object&gt;</c> for an async generator —
+    /// mirroring <c>DefineClassMethodsOnly</c>'s public-method logic (#720). The one exception is a
+    /// <em>static</em> async generator: that state machine is instance-only (#761), so it stays on the
+    /// linear path and keeps the plain <c>object</c> slot to avoid a return-type/stack mismatch for an
+    /// empty (yield-free) body.
+    /// </summary>
+    private Type ResolvePrivateMethodReturnType(Stmt.Function method, bool isStatic)
+    {
+        if (method.IsAsync && method.IsGenerator)
+            return isStatic ? typeof(object) : _types.IAsyncEnumerableOfObject;
+        if (method.IsAsync)
+            return _types.TaskOfObject;
+        if (method.IsGenerator)
+            return _types.IEnumerableOfObject;
+        return typeof(object);
+    }
+
     /// <summary>
     /// Extracts the .NET type name from a @DotNetType decorator if present.
     /// Returns null if the decorator is not present.
diff --git a/Compilation/ILCompiler.Generators.cs b/Compilation/ILCompiler.Generators.cs
index 566a793d..7fc608f1 100644
--- a/Compilation/ILCompiler.Generators.cs
+++ b/Compilation/ILCompiler.Generators.cs
@@ -333,16 +333,18 @@ private void EmitGeneratorMoveNextBody(GeneratorStateMachineBuilder smBuilder, S
     /// Emits the body of an instance generator method using a state machine.
     /// Called for class methods marked with IsGenerator = true.
     /// </summary>
-    private void EmitGeneratorMethodBody(MethodBuilder methodBuilder, Stmt.Function method, FieldInfo? fieldsField, bool isInstanceMethod = true)
+    private void EmitGeneratorMethodBody(MethodBuilder methodBuilder, Stmt.Function method, FieldInfo? fieldsField,
+        bool isInstanceMethod = true, string? currentClassName = null)
     {
         // Analyze generator function to determine yield points and hoisted variables
         var analysis = _generators.Analyzer.Analyze(method);
 
-        // Build state machine type. A static generator method (#692) has no `this`/instance fields,
-        // so it is set up like a free function (isInstanceMethod: false, static stub).
+        // Build state machine type. A static generator method (#692) has no `this`/instance fields, so it
+        // is set up like a free function (isInstanceMethod: false, static stub). The type name uses the
+        // MethodBuilder's (mangled) name so a private generator's `#p` lexeme doesn't put a `#` in it (#720).
         var smBuilder = new GeneratorStateMachineBuilder(_moduleBuilder, _types, _generators.StateMachineCounter++);
         smBuilder.DefineStateMachine(
-            $"{methodBuilder.DeclaringType!.Name}_{method.Name.Lexeme}",
+            $"{methodBuilder.DeclaringType!.Name}_{methodBuilder.Name}",
             analysis,
             isInstanceMethod: isInstanceMethod,
             runtime: _runtime
@@ -391,8 +393,9 @@ private void EmitGeneratorMethodBody(MethodBuilder methodBuilder, Stmt.Function
             ImportedNames = _importedNames,
             ClassExprBuilders = _classExprs.Builders,
             IsStrictMode = _isStrictMode || CheckForUseStrict(method.Body),
-            // ES2022 Private Class Elements support for generator methods
-            CurrentClassName = methodBuilder.DeclaringType?.Name,
+            // ES2022 Private Class Elements support for generator methods (a private generator threads
+            // its QUALIFIED class name so nested private member access resolves under modules — #720).
+            CurrentClassName = currentClassName ?? methodBuilder.DeclaringType?.Name,
             CurrentClassBuilder = methodBuilder.DeclaringType as TypeBuilder,
             // Registry services
             ClassRegistry = GetClassRegistry(),
@@ -437,13 +440,11 @@ private void EmitGeneratorInstanceStubMethod(
             il.Emit(OpCodes.Stfld, smBuilder.ThisField);
         }
 
-        // Get the typed parameter types for the method
-        // We need to box value types since state machine fields are object-typed
-        string? className = methodBuilder.DeclaringType?.Name;
-        string methodName = methodBuilder.Name;
-        Type[] paramTypes = className != null
-            ? ParameterTypeResolver.ResolveMethodParameters(className, methodName, parameters, _typeMapper, _typeMap)
-            : parameters.Select(_ => typeof(object)).ToArray();
+        // Box value types since state machine fields are object-typed. Decide from the method's ACTUAL
+        // IL signature (methodBuilder.GetParameters()), not the AST-resolved types: a private method's
+        // parameters are all `object` slots, so boxing the AST-resolved value type (e.g. Double) would
+        // mismatch the `object` argument actually loaded (StackUnexpected). Mirrors EmitAsyncStubMethod.
+        var paramTypes = methodBuilder.GetParameters();
 
         // Copy parameters to state machine fields (instance methods start params at index 1)
         for (int i = 0; i < parameters.Count; i++)
@@ -455,10 +456,9 @@ private void EmitGeneratorInstanceStubMethod(
                 il.Emit(OpCodes.Dup);  // Keep state machine reference on stack
                 il.Emit(OpCodes.Ldarg, i + 1);  // +1 because 'this' is at index 0
 
-                // Box value types since state machine fields are object-typed
-                if (i < paramTypes.Length && paramTypes[i].IsValueType)
+                if (i < paramTypes.Length && paramTypes[i].ParameterType.IsValueType)
                 {
-                    il.Emit(OpCodes.Box, paramTypes[i]);
+                    il.Emit(OpCodes.Box, paramTypes[i].ParameterType);
                 }
 
                 il.Emit(OpCodes.Stfld, field);
@@ -488,11 +488,11 @@ private void EmitGeneratorStaticStubMethod(
         // Create new instance of the state machine
         il.Emit(OpCodes.Newobj, smBuilder.Constructor);
 
-        string? className = methodBuilder.DeclaringType?.Name;
-        string methodName = methodBuilder.Name;
-        Type[] paramTypes = className != null
-            ? ParameterTypeResolver.ResolveMethodParameters(className, methodName, parameters, _typeMapper, _typeMap)
-            : parameters.Select(_ => typeof(object)).ToArray();
+        // Box value types since state machine fields are object-typed. Decide from the method's ACTUAL
+        // IL signature (methodBuilder.GetParameters()), not the AST-resolved types: a private static
+        // method's parameters are all `object` slots, so boxing the AST-resolved value type would
+        // mismatch the `object` argument actually loaded (StackUnexpected). Mirrors EmitAsyncStubMethod.
+        var paramTypes = methodBuilder.GetParameters();
 
         // Copy parameters to state machine fields (static methods start params at index 0).
         for (int i = 0; i < parameters.Count; i++)
@@ -503,10 +503,9 @@ private void EmitGeneratorStaticStubMethod(
                 il.Emit(OpCodes.Dup);  // Keep state machine reference on stack
                 il.Emit(OpCodes.Ldarg, i);
 
-                // Box value types since state machine fields are object-typed
-                if (i < paramTypes.Length && paramTypes[i].IsValueType)
+                if (i < paramTypes.Length && paramTypes[i].ParameterType.IsValueType)
                 {
-                    il.Emit(OpCodes.Box, paramTypes[i]);
+                    il.Emit(OpCodes.Box, paramTypes[i].ParameterType);
                 }
 
                 il.Emit(OpCodes.Stfld, field);
diff --git a/Compilation/StatementEmitterBase.cs b/Compilation/StatementEmitterBase.cs
index 84efca8d..5e8745f5 100644
--- a/Compilation/StatementEmitterBase.cs
+++ b/Compilation/StatementEmitterBase.cs
@@ -1000,6 +1000,78 @@ protected static Stmt UnwrapLabelChain(Stmt.LabeledStatement ls, out List<string
     protected static bool IsLabelableLoop(Stmt stmt)
         => stmt is Stmt.While or Stmt.DoWhile or Stmt.For or Stmt.ForOf or Stmt.ForIn;
 
+    /// <summary>
+    /// Detects return/break/continue that would transfer control out of the surrounding try
+    /// region. Over-approximates conservatively (labeled break/continue are always treated as
+    /// escaping): a false positive only costs a statement some mini-segment exception coverage,
+    /// whereas a false negative would emit a <c>br</c>/<c>ret</c> inside a protected region (illegal IL).
+    /// Nested function/arrow bodies are not traversed (their returns are their own).
+    /// </summary>
+    /// <remarks>
+    /// Shared by the suspension-aware emitters (generator, async generator, async function): each
+    /// segments a flag-based try body so a suspension point or a non-local exit lands at the top level
+    /// (outside the mini IL try/catch), where its <c>ret</c>/<c>br</c>/<c>Leave</c> is legal.
+    /// </remarks>
+    protected static bool ContainsEscapingExit(Stmt stmt, bool insideLoop, bool insideSwitch)
+    {
+        switch (stmt)
+        {
+            case Stmt.Return:
+                return true;
+            case Stmt.Break b:
+                return b.Label != null || !(insideLoop || insideSwitch);
+            case Stmt.Continue c:
+                return c.Label != null || !insideLoop;
+            case Stmt.If i:
+                return ContainsEscapingExit(i.ThenBranch, insideLoop, insideSwitch)
+                    || (i.ElseBranch != null && ContainsEscapingExit(i.ElseBranch, insideLoop, insideSwitch));
+            case Stmt.Block b:
+                if (b.Statements == null) return false;
+                foreach (var s in b.Statements)
+                    if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
+                return false;
+            case Stmt.Sequence seq:
+                foreach (var s in seq.Statements)
+                    if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
+                return false;
+            case Stmt.While w:
+                return ContainsEscapingExit(w.Body, insideLoop: true, insideSwitch);
+            case Stmt.DoWhile dw:
+                return ContainsEscapingExit(dw.Body, insideLoop: true, insideSwitch);
+            case Stmt.For f:
+                return ContainsEscapingExit(f.Body, insideLoop: true, insideSwitch);
+            case Stmt.ForOf fo:
+                return ContainsEscapingExit(fo.Body, insideLoop: true, insideSwitch);
+            case Stmt.ForIn fi:
+                return ContainsEscapingExit(fi.Body, insideLoop: true, insideSwitch);
+            case Stmt.Switch s:
+                foreach (var c in s.Cases)
+                    foreach (var cs in c.Body)
+                        if (ContainsEscapingExit(cs, insideLoop, insideSwitch: true)) return true;
+                if (s.DefaultBody != null)
+                    foreach (var ds in s.DefaultBody)
+                        if (ContainsEscapingExit(ds, insideLoop, insideSwitch: true)) return true;
+                return false;
+            case Stmt.LabeledStatement ls:
+                return ContainsEscapingExit(ls.Statement, insideLoop, insideSwitch);
+            case Stmt.TryCatch t:
+                if (ContainsEscapingExit2(t.TryBlock, insideLoop, insideSwitch)) return true;
+                if (t.CatchBlock != null && ContainsEscapingExit2(t.CatchBlock, insideLoop, insideSwitch)) return true;
+                if (t.FinallyBlock != null && ContainsEscapingExit2(t.FinallyBlock, insideLoop, insideSwitch)) return true;
+                return false;
+            default:
+                return false;
+        }
+    }
+
+    /// <summary>Any statement in <paramref name="statements"/> contains an escaping exit (see <see cref="ContainsEscapingExit"/>).</summary>
+    protected static bool ContainsEscapingExit2(List<Stmt> statements, bool insideLoop, bool insideSwitch)
+    {
+        foreach (var s in statements)
+            if (ContainsEscapingExit(s, insideLoop, insideSwitch)) return true;
+        return false;
+    }
+
     /// <summary>
     /// Emits a switch statement.
     /// </summary>
diff --git a/Execution/Interpreter.Async.cs b/Execution/Interpreter.Async.cs
index 9bde5942..1bb1dc61 100644
--- a/Execution/Interpreter.Async.cs
+++ b/Execution/Interpreter.Async.cs
@@ -60,6 +60,12 @@ internal async Task<ExecutionResult> ExecuteBlockAsync(List<Stmt> statements, Ru
 
     private async Task<ExecutionResult> ExecuteForOfAsync(Stmt.ForOf forOf)
     {
+        // Drain any labels parked by ExecuteLabeledStatementAsyncVT before evaluating the iterable, so a
+        // `break`/`continue <label>` targeting this loop (including via the async-iterator path below) is
+        // matched here rather than escaping — and so a labeled loop produced by the iterable expression
+        // can't steal this loop's label. TakePendingLoopLabels returns empty when none are parked, so the
+        // unlabeled path is unchanged (#728).
+        var labels = TakePendingLoopLabels();
         object? iterable = (await EvaluateAsync(forOf.Iterable)).ToObject();
 
         // For 'for await...of', check for async iterator protocol first
@@ -68,7 +74,7 @@ private async Task<ExecutionResult> ExecuteForOfAsync(Stmt.ForOf forOf)
             var asyncIterator = TryGetAsyncIterator(iterable);
             if (asyncIterator != null)
             {
-                return await IterateAsyncIterator(asyncIterator, forOf);
+                return await IterateAsyncIterator(asyncIterator, forOf, labels);
             }
             // Fall through to sync iterator with async unwrap
         }
@@ -83,9 +89,10 @@ private async Task<ExecutionResult> ExecuteForOfAsync(Stmt.ForOf forOf)
                 object? value = forOf.IsAsync && item is Task<object?> t ? await AwaitPreservingEnvironment(t) : item;
 
                 var result = await ExecuteLoopBodyAsync(forOf.Variable.Lexeme, value, forOf.Body);
-                if (result.Type == ExecutionResult.ResultType.Break && result.TargetLabel == null) return ExecutionResult.Success();
-                if (result.Type == ExecutionResult.ResultType.Continue && result.TargetLabel == null) continue;
-                if (result.IsAbrupt) return result;
+                var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, labels);
+                if (shouldBreak) return ExecutionResult.Success();
+                if (shouldContinue) continue;
+                if (abruptResult.HasValue) return abruptResult.Value;
 
                 // Process any pending timer callbacks
                 ProcessPendingCallbacks();
@@ -111,7 +118,7 @@ private async Task<ExecutionResult> ExecuteForOfAsync(Stmt.ForOf forOf)
             object? value = forOf.IsAsync && item is Task<object?> t ? await t : item;
 
             var result = await ExecuteLoopBodyAsync(forOf.Variable.Lexeme, value, forOf.Body);
-            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, null);
+            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, labels);
             if (shouldBreak) return ExecutionResult.Success();
             if (shouldContinue) continue;
             if (abruptResult.HasValue) return abruptResult.Value;
@@ -203,7 +210,7 @@ private async Task<ExecutionResult> ExecuteLoopBodyAsync(string varName, object?
     /// <summary>
     /// Iterates an async iterator by repeatedly calling .next() and awaiting results.
     /// </summary>
-    private async Task<ExecutionResult> IterateAsyncIterator(object asyncIterator, Stmt.ForOf forOf)
+    private async Task<ExecutionResult> IterateAsyncIterator(object asyncIterator, Stmt.ForOf forOf, IReadOnlyList<string>? labels = null)
     {
         // The loop body must run in the for-await statement's own lexical scope, regardless of how the
         // iterator's next() mutates the interpreter's ambient environment. The eager-drain async generator
@@ -253,7 +260,7 @@ private async Task<ExecutionResult> IterateAsyncIterator(object asyncIterator, S
             if (done) break;
 
             var result = await ExecuteLoopBodyAsync(forOf.Variable.Lexeme, value, forOf.Body);
-            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, null);
+            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, labels);
             if (shouldBreak) return ExecutionResult.Success();
             if (shouldContinue) continue;
             if (abruptResult.HasValue) return abruptResult.Value;
@@ -319,6 +326,7 @@ private async Task<ExecutionResult> IterateAsyncIterator(object asyncIterator, S
 
     private async Task<ExecutionResult> ExecuteForInAsync(Stmt.ForIn forIn)
     {
+        var labels = TakePendingLoopLabels();
         object? obj = (await EvaluateAsync(forIn.Object)).ToObject();
 
         IEnumerable<string> keys = obj switch
@@ -336,7 +344,7 @@ private async Task<ExecutionResult> ExecuteForInAsync(Stmt.ForIn forIn)
         foreach (var key in keys)
         {
             var result = await ExecuteLoopBodyAsync(forIn.Variable.Lexeme, key, forIn.Body);
-            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, null);
+            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, labels);
             if (shouldBreak) return ExecutionResult.Success();
             if (shouldContinue) continue;
             if (abruptResult.HasValue) return abruptResult.Value;
@@ -400,10 +408,11 @@ internal async ValueTask<ExecutionResult> ExecuteIfAsyncVT(Stmt.If ifStmt)
 
     internal async ValueTask<ExecutionResult> ExecuteWhileAsyncVT(Stmt.While whileStmt)
     {
+        var labels = TakePendingLoopLabels();
         while (IsTruthy(await EvaluateAsync(whileStmt.Condition)))
         {
             var result = await ExecuteStatementAsync(whileStmt.Body);
-            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, null);
+            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, labels);
             if (shouldBreak) return ExecutionResult.Success();
             if (shouldContinue) continue;
             if (abruptResult.HasValue) return abruptResult.Value;
@@ -414,10 +423,11 @@ internal async ValueTask<ExecutionResult> ExecuteWhileAsyncVT(Stmt.While whileSt
 
     internal async ValueTask<ExecutionResult> ExecuteDoWhileAsyncVT(Stmt.DoWhile doWhileStmt)
     {
+        var labels = TakePendingLoopLabels();
         do
         {
             var result = await ExecuteStatementAsync(doWhileStmt.Body);
-            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, null);
+            var (shouldBreak, shouldContinue, abruptResult) = HandleLoopResult(result, labels);
             if (shouldBreak) return ExecutionResult.Success();
             if (shouldContinue) continue;
             if (abruptResult.HasValue) return abruptResult.Value;
@@ -428,6 +438,9 @@ internal async ValueTask<ExecutionResult> ExecuteDoWhileAsyncVT(Stmt.DoWhile doW
 
     internal async ValueTask<ExecutionResult> ExecuteForAsyncVT(Stmt.For forStmt)
     {
+        // Drain labels parked for this loop so a `break`/`continue <label>` targeting it (e.g. from an
+        // inner `for await`) is matched here instead of escaping. Empty when unlabeled (#728).
+        var labels = TakePendingLoopLabels();
         RuntimeEnvironment loopEnv = new(_environment);
         using (PushScope(loopEnv))
         {
@@ -442,8 +455,8 @@ internal async ValueTask<ExecutionResult> ExecuteForAsyncVT(Stmt.For forStmt)
             while (forStmt.Condition == null || IsTruthy(await EvaluateAsync(forStmt.Condition)))
             {
                 var result = await ExecuteStatementAsync(forStmt.Body);
-                if (result.Type == ExecutionResult.ResultType.Break && result.TargetLabel == null) break;
-                if (result.Type == ExecutionResult.ResultType.Continue && result.TargetLabel == null)
+                if (result.Type == ExecutionResult.ResultType.Break && TargetsThisLoop(result.TargetLabel, labels)) break;
+                if (result.Type == ExecutionResult.ResultType.Continue && TargetsThisLoop(result.TargetLabel, labels))
                 {
                     if (perIterationNames != null)
                         CreatePerIterationEnvironment(loopEnv, perIterationNames);
@@ -473,6 +486,57 @@ internal async ValueTask<ExecutionResult> ExecuteForInAsyncVT(Stmt.ForIn forIn)
         return await ExecuteForInAsync(forIn);
     }
 
+    /// <summary>
+    /// Async analog of <see cref="ExecuteLabeledStatement"/>. Parks the chain's labels for the loop it
+    /// wraps (drained by the async loop at entry, so a matching <c>continue</c>/<c>break</c> targets that
+    /// loop) and executes the inner statement through the <em>async</em> path. Registering this is what
+    /// routes a labeled <c>for await</c> to the async-iterator lowering instead of the synchronous
+    /// executor — the latter throws "requires an iterable" on an async iterator (#728).
+    /// </summary>
+    internal async ValueTask<ExecutionResult> ExecuteLabeledStatementAsyncVT(Stmt.LabeledStatement labeledStmt)
+    {
+        // Flatten a chain of labels (a: b: stmt) down to the statement they wrap.
+        List<string> labels = [];
+        Stmt inner = labeledStmt;
+        while (inner is Stmt.LabeledStatement ls)
+        {
+            labels.Add(ls.Label.Lexeme);
+            inner = ls.Statement;
+        }
+
+        bool isLoop = inner is Stmt.While or Stmt.DoWhile or Stmt.For or Stmt.ForOf or Stmt.ForIn;
+
+        if (isLoop)
+        {
+            // Park the labels for the loop; it drains them at entry and handles a matching
+            // continue/break itself. Restore on the way out so an undrained label can't leak.
+            int baseCount = _pendingLoopLabels.Count;
+            _pendingLoopLabels.AddRange(labels);
+            ExecutionResult result;
+            try
+            {
+                result = await ExecuteStatementAsync(inner);
+            }
+            finally
+            {
+                if (_pendingLoopLabels.Count > baseCount)
+                    _pendingLoopLabels.RemoveRange(baseCount, _pendingLoopLabels.Count - baseCount);
+            }
+            // The loop absorbs continue/break for its labels; guard a matching break defensively.
+            if (result.Type == ExecutionResult.ResultType.Break &&
+                result.TargetLabel != null && labels.Contains(result.TargetLabel))
+                return ExecutionResult.Success();
+            return result;
+        }
+
+        // Non-loop labeled statement: only `break <label>` is meaningful.
+        var r = await ExecuteStatementAsync(inner);
+        if (r.Type == ExecutionResult.ResultType.Break &&
+            r.TargetLabel != null && labels.Contains(r.TargetLabel))
+            return ExecutionResult.Success();
+        return r;
+    }
+
     internal async ValueTask<ExecutionResult> ExecuteSwitchAsyncVT(Stmt.Switch switchStmt)
     {
         return await ExecuteSwitchCore(_asyncContext, switchStmt);
diff --git a/Execution/InterpreterRegistry.cs b/Execution/InterpreterRegistry.cs
index 230e75b0..afc7b4b3 100644
--- a/Execution/InterpreterRegistry.cs
+++ b/Execution/InterpreterRegistry.cs
@@ -36,6 +36,9 @@ public static NodeRegistry<Interpreter, RuntimeValue, ExecutionResult> Create()
             .RegisterStmtAsync<Stmt.For>((s, i) => i.ExecuteForAsyncVT(s))
             .RegisterStmtAsync<Stmt.ForOf>((s, i) => i.ExecuteForOfAsyncVT(s))
             .RegisterStmtAsync<Stmt.ForIn>((s, i) => i.ExecuteForInAsyncVT(s))
+            // #728: route a labeled `for await` (and any labeled loop in async code) through the async
+            // path so the for-await async-iterator lowering runs and labels are parked for the loop.
+            .RegisterStmtAsync<Stmt.LabeledStatement>((s, i) => i.ExecuteLabeledStatementAsyncVT(s))
             .RegisterStmtAsync<Stmt.Switch>((s, i) => i.ExecuteSwitchAsyncVT(s))
             .RegisterStmtAsync<Stmt.TryCatch>((s, i) => i.ExecuteTryCatchAsyncVT(s))
             .RegisterStmtAsync<Stmt.Throw>((s, i) => i.ExecuteThrowAsyncVT(s))
diff --git a/SharpTS.Tests/Compilation/AsyncArrowNoDeadDuplicateTests.cs b/SharpTS.Tests/Compilation/AsyncArrowNoDeadDuplicateTests.cs
new file mode 100644
index 00000000..a78d946e
--- /dev/null
+++ b/SharpTS.Tests/Compilation/AsyncArrowNoDeadDuplicateTests.cs
@@ -0,0 +1,118 @@
+using System.Reflection;
+using SharpTS.Parsing;
+using SharpTS.Tests.Infrastructure;
+using Xunit;
+
+namespace SharpTS.Tests.Compilation;
+
+/// <summary>
+/// Regression tests for #721: an <c>async</c> arrow nested in an <c>async</c> class method got TWO async
+/// state machines emitted — the live nested one (which the method invokes) and a redundant standalone one
+/// (<c>&lt;&gt;c__AsyncArrow_N</c> with <c>&lt;&gt;captured_*</c> fields) that is never invoked.
+/// <c>DefineTopLevelAsyncArrows</c> ran before class-method state machines were registered, so a method's
+/// arrows looked "unclaimed" and got a dead standalone builder. The fix skips an arrow that an enclosing
+/// async function/method's state machine will claim (walking the enclosing-callable chain), while leaving
+/// arrows behind a sync arrow/method — or genuinely top-level — with their needed standalone builder.
+/// </summary>
+public class AsyncArrowNoDeadDuplicateTests
+{
+    private static int CountAsyncArrowTypes(Assembly asm)
+    {
+        Type?[] types;
+        try { types = asm.GetTypes(); }
+        catch (ReflectionTypeLoadException ex) { types = ex.Types; }
+        return types.Count(t => t?.Name?.Contains("AsyncArrow") == true);
+    }
+
+    [Fact]
+    public void AsyncArrowInAsyncMethod_EmitsExactlyOneStateMachine()
+    {
+        // The #721 repro: one async arrow `w` directly inside the async method `run`.
+        var source = """
+            class C {
+              async run() {
+                const w = async () => { await Promise.resolve(1); return 5; };
+                return await w();
+              }
+            }
+            new C().run().then(r => console.log(r));
+            """;
+
+        var (assembly, output) = TestHarness.CompileAndRun(source, DecoratorMode.None);
+
+        Assert.Equal("5\n", output);
+        // Exactly one async-arrow state machine — the live nested one. Before #721 a second, dead
+        // standalone duplicate was also emitted.
+        Assert.Equal(1, CountAsyncArrowTypes(assembly));
+    }
+
+    [Fact]
+    public void NestedAsyncArrowsInAsyncMethod_NoDeadDuplicates()
+    {
+        // Two async arrows, one nested in the other, both inside the async method: both are claimed by
+        // the method's state machine, so neither gets a standalone duplicate (was 4 types, now 2).
+        var source = """
+            class C {
+              async run() {
+                const a = async () => {
+                  const w = async () => { await Promise.resolve(1); return 8; };
+                  return await w();
+                };
+                return await a();
+              }
+            }
+            new C().run().then(r => console.log(r));
+            """;
+
+        var (assembly, output) = TestHarness.CompileAndRun(source, DecoratorMode.None);
+
+        Assert.Equal("8\n", output);
+        Assert.Equal(2, CountAsyncArrowTypes(assembly));
+    }
+
+    [Fact]
+    public void AsyncArrowInSyncMethod_StillEmitsItsStandalone()
+    {
+        // An async arrow behind a SYNC method is not claimed by any async state machine, so it still
+        // needs (and gets) its standalone builder — the skip must not over-reach.
+        var source = """
+            class C {
+              m() {
+                const w = async () => { await Promise.resolve(1); return 5; };
+                return w;
+              }
+            }
+            const f = new C().m();
+            f().then(r => console.log(r));
+            """;
+
+        var (assembly, output) = TestHarness.CompileAndRun(source, DecoratorMode.None);
+
+        Assert.Equal("5\n", output);
+        Assert.Equal(1, CountAsyncArrowTypes(assembly));
+    }
+
+    [Fact]
+    public void AsyncArrowBehindSyncArrowInAsyncMethod_StillEmitsItsStandalone()
+    {
+        // An async arrow behind a SYNC arrow (itself in an async method) is not claimed either — the
+        // sync arrow breaks the async chain — so its standalone builder must remain.
+        var source = """
+            class C {
+              async run() {
+                const a = () => {
+                  const w = async () => { await Promise.resolve(1); return 7; };
+                  return w;
+                };
+                return await a()();
+              }
+            }
+            new C().run().then(r => console.log(r));
+            """;
+
+        var (assembly, output) = TestHarness.CompileAndRun(source, DecoratorMode.None);
+
+        Assert.Equal("7\n", output);
+        Assert.Equal(1, CountAsyncArrowTypes(assembly));
+    }
+}
diff --git a/SharpTS.Tests/Compilation/EmitterSyncTests.cs b/SharpTS.Tests/Compilation/EmitterSyncTests.cs
index 9bbcf1c7..d41d5384 100644
--- a/SharpTS.Tests/Compilation/EmitterSyncTests.cs
+++ b/SharpTS.Tests/Compilation/EmitterSyncTests.cs
@@ -46,6 +46,8 @@ public class EmitterSyncTests
             "EmitForOf",            // for-await-of protocol dispatch
             "EmitForAwaitOf",       // #631: override the shared base to SUSPEND on next()/return() (vs blocking GetResult)
             "EmitLabeledStatement", // Labeled continue for for loops (base doesn't handle correctly)
+            "EmitBranchToLabel",    // #727: Leave instead of Br when a break/continue leaves a real IL exception block
+
             "EmitAwait",            // Core: suspend/resume state machine
             "EmitArrowFunction",    // Display class in state machine context
             "EmitExpressionAsDouble", // Literal optimization
diff --git a/SharpTS.Tests/SharedTests/AsyncTryControlFlowTests.cs b/SharpTS.Tests/SharedTests/AsyncTryControlFlowTests.cs
new file mode 100644
index 00000000..e4d4bf87
--- /dev/null
+++ b/SharpTS.Tests/SharedTests/AsyncTryControlFlowTests.cs
@@ -0,0 +1,197 @@
+using SharpTS.Tests.Infrastructure;
+using Xunit;
+
+namespace SharpTS.Tests.SharedTests;
+
+/// <summary>
+/// Regression tests for #727: in compiled mode, a <c>break</c>/<c>continue</c> that leaves a
+/// <c>try</c> inside an <c>async function</c> body previously emitted a <c>Br</c> out of the real IL
+/// exception region instead of a <c>Leave</c> — unverifiable IL (<c>BranchOutOfTry</c>) surfacing as an
+/// <c>InvalidProgramException</c> when the async state machine starts. The fix mirrors the generator
+/// emitters: <see cref="SharpTS.Compilation.AsyncMoveNextEmitter"/> now overrides
+/// <c>EmitBranchToLabel</c> to emit <c>Leave</c> while inside a real IL exception block (depth tracked
+/// in <c>EmitSimpleTryCatch</c>), and treats an escaping <c>break</c>/<c>continue</c> as a
+/// segment-breaker in <c>EmitTryBodyWithAwaits</c> so its jump lands at the top level (outside the
+/// mini IL try). The interpreter already behaved correctly, so the cross-mode theories double as a
+/// parity guard. The <c>CompileVerifyAndRun</c> facts pin IL validity (the runtime JIT is lenient).
+/// </summary>
+public class AsyncTryControlFlowTests
+{
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void BreakOutOfSimpleTry_InAsync(ExecutionMode mode)
+    {
+        // The exact #727 break repro.
+        var source = """
+            async function main() {
+              let n = 0;
+              for (let i = 0; i < 5; i++) {
+                try { if (i === 2) break; n++; } catch (e) {}
+              }
+              console.log("n=" + n);
+            }
+            main();
+            """;
+
+        Assert.Equal("n=2\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void ContinueOutOfSimpleTry_InAsync(ExecutionMode mode)
+    {
+        // The exact #727 continue repro.
+        var source = """
+            async function main() {
+              let sum = 0;
+              for (let i = 0; i < 5; i++) {
+                try { if (i === 1) continue; sum += i; } catch (e) {}
+              }
+              console.log("sum=" + sum);
+            }
+            main();
+            """;
+
+        Assert.Equal("sum=9\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void BreakOutOfTryContainingAwait_InAsync(ExecutionMode mode)
+    {
+        // break leaves a try whose body awaits → the flag-based try path. The escaping break must be
+        // emitted at the top level (outside the mini IL try), not Br out of it.
+        var source = """
+            function delay(v: number): Promise<number> { return new Promise(r => r(v)); }
+            async function main() {
+              let n = 0;
+              for (let i = 0; i < 5; i++) {
+                try {
+                  const v = await delay(i);
+                  if (v === 2) break;
+                  n += v;
+                } catch (e) {}
+              }
+              console.log("n=" + n);
+            }
+            main();
+            """;
+
+        Assert.Equal("n=1\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void BreakOutOfTryWithFinally_NoAwait_RunsFinally(ExecutionMode mode)
+    {
+        // A try with no awaits is a real IL try/finally (EmitSimpleTryCatch). The break Leaves it,
+        // which runs the real finally — so cleanup happens even on the early exit.
+        var source = """
+            async function main() {
+              let log = "";
+              for (let i = 0; i < 4; i++) {
+                try { if (i === 2) break; log += "t" + i; } finally { log += "f" + i; }
+              }
+              console.log(log);
+            }
+            main();
+            """;
+
+        Assert.Equal("t0f0t1f1f2\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void BreakToInnerLoopInsideTry_DoesNotEscapeTry(ExecutionMode mode)
+    {
+        // The break targets a loop nested INSIDE the try, so it stays a legal in-region branch and the
+        // statements after the inner loop (still inside the try) run.
+        var source = """
+            async function main() {
+              let log = "";
+              try {
+                for (let j = 0; j < 3; j++) { if (j === 1) break; log += "j" + j; }
+                log += "after";
+              } catch (e) {}
+              console.log(log);
+            }
+            main();
+            """;
+
+        Assert.Equal("j0after\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void SwitchBreakInsideTry_InAsync(ExecutionMode mode)
+    {
+        // An unlabeled break inside a switch that is inside a try belongs to the switch, not the loop.
+        var source = """
+            async function main() {
+              let log = "";
+              for (let i = 0; i < 3; i++) {
+                try {
+                  switch (i) { case 1: log += "one"; break; default: log += "d" + i; }
+                  log += "|";
+                } catch (e) {}
+              }
+              console.log(log);
+            }
+            main();
+            """;
+
+        Assert.Equal("d0|one|d2|\n", TestHarness.Run(source, mode));
+    }
+
+    [Fact]
+    public void LabeledBreakOutOfTryWithAwait_AcrossNestedLoops_Compiled()
+    {
+        // Labeled `break outer` leaves a try whose body awaits, across nested loops. Compiled mode is
+        // correct; the interpreter mishandles this shape (tracked separately), so this is compiled-only.
+        var source = """
+            async function main() {
+              let log = "";
+              outer: for (let i = 0; i < 3; i++) {
+                for (let j = 0; j < 3; j++) {
+                  try {
+                    const x = await Promise.resolve(i * 10 + j);
+                    if (x === 11) break outer;
+                    log += x + ",";
+                  } catch (e) {}
+                }
+              }
+              console.log(log);
+            }
+            main();
+            """;
+
+        var (errors, output) = TestHarness.CompileVerifyAndRun(source);
+        Assert.Empty(errors);
+        Assert.Equal("0,1,2,10,\n", output);
+    }
+
+    [Fact]
+    public void BreakContinueOutOfTry_ProduceValidIL()
+    {
+        // Pin IL validity directly (the runtime JIT is lenient and would run invalid IL anyway).
+        var source = """
+            async function main() {
+              let n = 0;
+              for (let i = 0; i < 5; i++) {
+                try { if (i === 2) break; n++; } catch (e) {}
+              }
+              for (let i = 0; i < 5; i++) {
+                try { if (i === 1) continue; n += i; } catch (e) {}
+              }
+              for (let i = 0; i < 5; i++) {
+                try { const v = await Promise.resolve(i); if (v === 2) break; n += v; } catch (e) {}
+              }
+              console.log("n=" + n);
+            }
+            main();
+            """;
+
+        var (errors, _) = TestHarness.CompileVerifyAndRun(source);
+        Assert.Empty(errors);
+    }
+}
diff --git a/SharpTS.Tests/SharedTests/LabeledForAwaitTests.cs b/SharpTS.Tests/SharedTests/LabeledForAwaitTests.cs
new file mode 100644
index 00000000..1764bc8e
--- /dev/null
+++ b/SharpTS.Tests/SharedTests/LabeledForAwaitTests.cs
@@ -0,0 +1,124 @@
+using SharpTS.Tests.Infrastructure;
+using Xunit;
+
+namespace SharpTS.Tests.SharedTests;
+
+/// <summary>
+/// Regression tests for #728: a <c>for await...of</c> that carries a label
+/// (<c>outer: for await (...)</c>) was iterated <em>synchronously</em> — the
+/// <see cref="SharpTS.Parsing.Stmt.ForOf.IsAsync"/> flag never reached the async-iteration lowering on
+/// the labeled path. It failed with "for...of requires an iterable" (interpreter) or a compile failure
+/// ("Label N has not been marked", from the unconsumed reserved await states) in compiled mode, while
+/// an unlabeled <c>for await</c> worked. The fix routes the labeled case through the same async lowering:
+/// the interpreter registers an async <c>LabeledStatement</c> handler (and the async loops drain the
+/// parked labels), and the compiled emitter's <c>EmitLabeledForOf</c> delegates to <c>EmitForAwaitOf</c>
+/// when <c>IsAsync</c>, threading the label so <c>break</c>/<c>continue &lt;label&gt;</c> resolve.
+/// </summary>
+public class LabeledForAwaitTests
+{
+    private const string Gen = "async function* g() { yield 1; yield 2; yield 3; yield 4; }\n";
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void LabeledForAwait_ContinueOuter(ExecutionMode mode)
+    {
+        // The exact #728 repro.
+        var source = Gen + """
+            async function main() {
+              let sum = 0;
+              outer: for await (const x of g()) {
+                if (x === 2) continue outer;
+                sum += x;
+              }
+              console.log(sum);
+            }
+            main();
+            """;
+
+        Assert.Equal("8\n", TestHarness.Run(source, mode));  // 1 + 3 + 4 (2 skipped)
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void LabeledForAwait_BreakOuter(ExecutionMode mode)
+    {
+        var source = Gen + """
+            async function main() {
+              let sum = 0;
+              outer: for await (const x of g()) {
+                if (x === 3) break outer;
+                sum += x;
+              }
+              console.log(sum);
+            }
+            main();
+            """;
+
+        Assert.Equal("3\n", TestHarness.Run(source, mode));  // 1 + 2, then break at 3
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void LabeledForAwait_ContinueOuterFromInnerLoop(ExecutionMode mode)
+    {
+        // `continue outer` from a regular loop nested in the for-await body resumes the for-await.
+        var source = Gen + """
+            async function main() {
+              let log = "";
+              outer: for await (const x of g()) {
+                for (let j = 0; j < 3; j++) {
+                  if (j === 1) continue outer;
+                  log += x + ":" + j + ",";
+                }
+              }
+              console.log(log);
+            }
+            main();
+            """;
+
+        Assert.Equal("1:0,2:0,3:0,4:0,\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void ForAwaitAsInnerLoop_BreakToOuterFor(ExecutionMode mode)
+    {
+        // A for-await nested inside a labeled regular `for`; `break outer` from inside the for-await.
+        var source = Gen + """
+            async function main() {
+              let log = "";
+              outer: for (let i = 0; i < 3; i++) {
+                for await (const x of g()) {
+                  if (x === 2 && i === 1) break outer;
+                  log += i + "/" + x + ",";
+                }
+              }
+              console.log(log);
+            }
+            main();
+            """;
+
+        Assert.Equal("0/1,0/2,0/3,0/4,1/1,\n", TestHarness.Run(source, mode));
+    }
+
+    [Fact]
+    public void LabeledForAwait_ProducesValidIL()
+    {
+        var source = Gen + """
+            async function main() {
+              let sum = 0;
+              outer: for await (const x of g()) {
+                if (x === 2) continue outer;
+                if (x === 4) break outer;
+                sum += x;
+              }
+              console.log(sum);
+            }
+            main();
+            """;
+
+        var (errors, output) = TestHarness.CompileVerifyAndRun(source);
+        Assert.Empty(errors);
+        Assert.Equal("4\n", output);  // 1 + 3 (2 skipped, break at 4)
+    }
+}
diff --git a/SharpTS.Tests/SharedTests/PrivateAsyncGeneratorMethodTests.cs b/SharpTS.Tests/SharedTests/PrivateAsyncGeneratorMethodTests.cs
new file mode 100644
index 00000000..67adf500
--- /dev/null
+++ b/SharpTS.Tests/SharedTests/PrivateAsyncGeneratorMethodTests.cs
@@ -0,0 +1,163 @@
+using SharpTS.Diagnostics.Exceptions;
+using SharpTS.Parsing;
+using SharpTS.Tests.Infrastructure;
+using Xunit;
+
+namespace SharpTS.Tests.SharedTests;
+
+/// <summary>
+/// Regression tests for #720: in compiled mode an <c>async</c> or generator ES2022 private method
+/// (<c>async #m</c>, <c>*#m</c>, <c>async *#m</c>) was emitted linearly into <c>__private_&lt;name&gt;</c>
+/// regardless of its kind — leaving a bare <c>object</c> on the stack for a method declared to return
+/// <c>Task&lt;object&gt;</c> (invalid IL: StackUnexpected) and rejecting <c>yield</c> ("Yield not
+/// supported"). The interpreter already handled both. The fix routes a private method's body through the
+/// same state-machine path as its public counterpart (<c>EmitAsyncMethodBody</c> /
+/// <c>EmitGeneratorMethodBody</c> / <c>EmitAsyncGeneratorMethodBody</c>, generalized for the private
+/// builder + qualified class name + static), with the parameter-default prologue moving into the state
+/// machine entry. The cross-mode theories double as a parity guard.
+/// </summary>
+public class PrivateAsyncGeneratorMethodTests
+{
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void AsyncPrivateMethod_Instance(ExecutionMode mode)
+    {
+        // The exact #720 async repro.
+        var source = """
+            class Q {
+              async #p(x: number): Promise<number> { return x; }
+              go(): Promise<number> { return this.#p(5); }
+            }
+            new Q().go().then(v => console.log(v));
+            """;
+
+        Assert.Equal("5\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void GeneratorPrivateMethod_Instance(ExecutionMode mode)
+    {
+        // The exact #720 generator repro.
+        var source = """
+            class G {
+              *#p(x: number): Generator<number> { yield x; yield x + 1; }
+              go(): number { let s = 0; for (const v of this.#p(5)) s += v; return s; }
+            }
+            console.log(new G().go());
+            """;
+
+        Assert.Equal("11\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void AsyncGeneratorPrivateMethod_Instance(ExecutionMode mode)
+    {
+        var source = """
+            class A {
+              async *#p(x: number) { yield x; yield x + 1; }
+              async go(): Promise<number> { let s = 0; for await (const v of this.#p(5)) s += v; return s; }
+            }
+            new A().go().then(v => console.log(v));
+            """;
+
+        Assert.Equal("11\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void StaticAsyncPrivateMethod(ExecutionMode mode)
+    {
+        var source = """
+            class Q {
+              static async #p(x: number): Promise<number> { return x * 2; }
+              static go(): Promise<number> { return Q.#p(5); }
+            }
+            Q.go().then(v => console.log(v));
+            """;
+
+        Assert.Equal("10\n", TestHarness.Run(source, mode));
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void AsyncPrivateMethod_AwaitsAndReachesOtherPrivateMembers(ExecutionMode mode)
+    {
+        // The async private method awaits, reads a private field, and calls another private method —
+        // confirming the state-machine body keeps full private-member access.
+        var source = """
+            class C {
+              #base = 100;
+              async #compute(x: number): Promise<number> {
+                const d = await Promise.resolve(x);
+                return d + this.#base + this.#double(x);
+              }
+              #double(x: number): number { return x * 2; }
+              async run(): Promise<number> { return await this.#compute(5); }
+            }
+            new C().run().then(v => console.log(v));
+            """;
+
+        Assert.Equal("115\n", TestHarness.Run(source, mode));  // 5 + 100 + 10
+    }
+
+    [Fact]
+    public void PrivateAsyncAndGeneratorMethods_ProduceValidIL()
+    {
+        // Pin IL validity directly (the runtime JIT is lenient and would run invalid IL anyway).
+        var source = """
+            class C {
+              #base = 1;
+              async #a(x: number): Promise<number> { return x + this.#base; }
+              *#g(x: number): Generator<number> { yield x; yield x + this.#base; }
+              async *#ag(x: number) { yield x; yield x + this.#base; }
+              async run(): Promise<number> {
+                let total = await this.#a(10);
+                for (const v of this.#g(20)) total += v;
+                for await (const v of this.#ag(30)) total += v;
+                return total;
+              }
+            }
+            new C().run().then(v => console.log(v));
+            """;
+
+        var errors = TestHarness.CompileAndVerifyOnly(source);
+        Assert.Empty(errors);
+    }
+
+    [Theory]
+    [MemberData(nameof(ExecutionModes.All), MemberType = typeof(ExecutionModes))]
+    public void StaticGeneratorPrivateMethod(ExecutionMode mode)
+    {
+        // Static generator support landed in #692; the static private form routes through the same
+        // static generator state machine.
+        var source = """
+            class G {
+              static *#p(x: number): Generator<number> { yield x; yield x + 1; }
+              static go(): number { let s = 0; for (const v of G.#p(5)) s += v; return s; }
+            }
+            console.log(G.go());
+            """;
+
+        Assert.Equal("11\n", TestHarness.Run(source, mode));
+    }
+
+    [Fact]
+    public void StaticAsyncGeneratorPrivate_ReportsCleanError_NotInvalidIL()
+    {
+        // Static async generators are not yet supported (the async-generator state machine is
+        // instance-only; the public static form fails the same way, #761). The static private form must
+        // report that clean compile error rather than emitting invalid IL — i.e. the fix routes only the
+        // supported cases.
+        var source = """
+            class A {
+              static async *#p(x: number) { yield x; yield x + 1; }
+              static async go(): Promise<number> { let s = 0; for await (const v of A.#p(5)) s += v; return s; }
+            }
+            A.go().then(v => console.log(v));
+            """;
+
+        Assert.Throws<CompileException>(() => TestHarness.CompileAndVerifyOnly(source, DecoratorMode.None));
+    }
+}