diff --git a/Jint.Benchmark/LoopDispatchBenchmarks.cs b/Jint.Benchmark/LoopDispatchBenchmarks.cs
index ecff02c82..bc01191f4 100644
--- a/Jint.Benchmark/LoopDispatchBenchmarks.cs
+++ b/Jint.Benchmark/LoopDispatchBenchmarks.cs
@@ -23,6 +23,8 @@ public class LoopDispatchBenchmarks
     private Prepared<Script> _strictEqualTest;
     private Prepared<Script> _looseEqualTest;
     private Prepared<Script> _moduloEqualTest;
+    private Prepared<Script> _ifChainLoop;
+    private Prepared<Script> _varDeclBody;
     private Prepared<Script> _arrayLengthBound;
     private Prepared<Script> _stringLengthBound;
 
@@ -83,6 +85,30 @@ public void Setup()
             f();
             """);
 
+        // the full stopwatch.js body shape: var-decl + 4-way modulo else-if chain whose branches
+        // call tiny closures + two dead member-read var-decls
+        _ifChainLoop = Engine.PrepareScript("""
+            function f() {
+                var c = { n: 0, a: function () { this.n++; }, b: function () { this.n--; } };
+                for (var i = 0; i < 100000; i++) {
+                    var z = i ^ 3;
+                    if (z % 2 == 0) c.a();
+                    else if (z % 3 == 0) c.b();
+                    else if (z % 5 == 0) c.a();
+                    else if (z % 7 == 0) c.b();
+                    var v = c.n;
+                }
+                return c.n;
+            }
+            f();
+            """);
+
+        // + one var declaration with an initializer (the `var z = x ^ y` statement alone)
+        _varDeclBody = Engine.PrepareScript("""
+            function f() { var n = 0; for (var i = 0; i < 100000; i++) { var z = i ^ 3; } return n; }
+            f();
+            """);
+
         // the member-bound loop test: `i < a.length` re-reads the live length every iteration
         // (6250 × 16 = 100k inner iterations)
         _arrayLengthBound = Engine.PrepareScript("""
@@ -107,6 +133,8 @@ public void Setup()
         _engine.Evaluate(_strictEqualTest);
         _engine.Evaluate(_looseEqualTest);
         _engine.Evaluate(_moduloEqualTest);
+        _engine.Evaluate(_ifChainLoop);
+        _engine.Evaluate(_varDeclBody);
         _engine.Evaluate(_arrayLengthBound);
         _engine.Evaluate(_stringLengthBound);
     }
@@ -138,6 +166,12 @@ public void Setup()
     [Benchmark]
     public JsValue ModuloEqualTest() => _engine.Evaluate(_moduloEqualTest);
 
+    [Benchmark]
+    public JsValue IfChainLoop() => _engine.Evaluate(_ifChainLoop);
+
+    [Benchmark]
+    public JsValue VarDeclBody() => _engine.Evaluate(_varDeclBody);
+
     [Benchmark]
     public JsValue ArrayLengthBound() => _engine.Evaluate(_arrayLengthBound);
 
diff --git a/Jint.Tests/Runtime/TightLoopTests.cs b/Jint.Tests/Runtime/TightLoopTests.cs
index 2f3c73f27..a91de3532 100644
--- a/Jint.Tests/Runtime/TightLoopTests.cs
+++ b/Jint.Tests/Runtime/TightLoopTests.cs
@@ -119,4 +119,215 @@ public void ConstraintConfiguredEngineStillEnforcesInsideLoops()
         Assert.Throws<Jint.Runtime.StatementsCountOverflowException>(() =>
             engine.Evaluate("(function () { var x = 0; for (var i = 0; i < 100000; i++) { x += 1; } })()"));
     }
+
+    [Fact]
+    public void IfChainBodyMatchesGenericPathExactly()
+    {
+        var engine = new Engine();
+        // same computation twice: the first shape is tight-eligible (if/else chain + var decls),
+        // the second carries a never-taken break that structurally disqualifies it, forcing the
+        // generic path — both must agree
+        var result = engine.Evaluate("""
+            (function () {
+                function tightShape() {
+                    var counts = [0, 0, 0, 0, 0];
+                    for (var x = 0; x < 200; x++) {
+                        var z = x ^ 3;
+                        if (z % 2 == 0) counts[0]++;
+                        else if (z % 3 == 0) counts[1]++;
+                        else if (z % 5 == 0) counts[2]++;
+                        else if (z % 7 == 0) counts[3]++;
+                        else counts[4]++;
+                        var v = counts.length;
+                    }
+                    return counts.join(',');
+                }
+                function genericShape() {
+                    var counts = [0, 0, 0, 0, 0];
+                    for (var x = 0; x < 200; x++) {
+                        var z = x ^ 3;
+                        if (z % 2 == 0) counts[0]++;
+                        else if (z % 3 == 0) counts[1]++;
+                        else if (z % 5 == 0) counts[2]++;
+                        else if (z % 7 == 0) counts[3]++;
+                        else counts[4]++;
+                        var v = counts.length;
+                        if (x > 100000) break;
+                    }
+                    return counts.join(',');
+                }
+                var a = tightShape();
+                var b = genericShape();
+                return (a === b) + ':' + a;
+            })()
+            """).AsString();
+
+        Assert.StartsWith("true:", result);
+    }
+
+    [Fact]
+    public void IfChainBodyRunsTightAtTopLevelWithTrailingStatement()
+    {
+        var engine = new Engine();
+        // trailing expression statement kills the loop's completion value → tight path engages
+        // at script top level; the loop calls closures exactly like the stopwatch benchmark
+        var result = engine.Evaluate("""
+            var n = 0;
+            var o = { inc: function () { n++; }, dec: function () { n--; } };
+            for (var x = 0; x < 100; x++) {
+                var z = x ^ 5;
+                if (z % 2 == 0) o.inc();
+                else if (z % 3 == 0) o.dec();
+                var v = o.inc;
+            }
+            n;
+            """).AsNumber();
+
+        var expected = 0;
+        for (var x = 0; x < 100; x++)
+        {
+            var z = x ^ 5;
+            if (z % 2 == 0) expected++;
+            else if (z % 3 == 0) expected--;
+        }
+
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void ThrowInsideTakenBranchPropagatesWithState()
+    {
+        var engine = new Engine();
+        var result = engine.Evaluate("""
+            (function () {
+                var i = 0, ran = 0;
+                try {
+                    for (i = 0; i < 10; i++) {
+                        var z = i ^ 1;
+                        if (z % 2 == 0) ran++;
+                        else mustNotExist();
+                    }
+                } catch (e) {
+                    return (e instanceof ReferenceError) + ':' + i + ':' + ran;
+                }
+                return 'no-throw';
+            })()
+            """).AsString();
+
+        // i=0 → z=1 → else branch throws before any increment
+        Assert.Equal("true:0:0", result);
+    }
+
+    [Fact]
+    public void NestedBranchBlockStopsAfterThrowingStatement()
+    {
+        var engine = new Engine();
+        // inside a multi-statement branch block, statements after a throwing one must not run
+        var result = engine.Evaluate("""
+            (function () {
+                var a = 0, b = 0;
+                try {
+                    for (var i = 0; i < 3; i++) {
+                        if (true) { a++; mustNotExist(); b++; }
+                    }
+                } catch (e) {
+                    return a + ':' + b;
+                }
+                return 'no-throw';
+            })()
+            """).AsString();
+
+        Assert.Equal("1:0", result);
+    }
+
+    [Fact]
+    public void BreakContinueReturnBodiesKeepExactSemantics()
+    {
+        var engine = new Engine();
+        // break/continue/return statements structurally disqualify the tight path; semantics
+        // must be untouched
+        var result = engine.Evaluate("""
+            (function () {
+                var s = '';
+                for (var i = 0; i < 5; i++) {
+                    if (i === 2) continue;
+                    if (i === 4) break;
+                    s += i;
+                }
+                function returner() {
+                    for (var j = 0; j < 10; j++) {
+                        if (j === 3) return 'r' + j;
+                    }
+                    return 'end';
+                }
+                return s + ':' + i + ':' + returner();
+            })()
+            """).AsString();
+
+        Assert.Equal("013:4:r3", result);
+    }
+
+    [Fact]
+    public void FlattenedConstBodyKeepsPerIterationTdz()
+    {
+        var engine = new Engine();
+        // let-header + const-body loops flatten into the pooled loop env and stay tight-eligible;
+        // the body slots must be re-TDZ'd each iteration, so a read before the const initializes
+        // throws — also on iterations after the first (stale value from iteration 1 must not leak)
+        var untaken = engine.Evaluate("""
+            (function () {
+                let total = 0;
+                for (let i = 0; i < 3; i++) {
+                    if (false) z;
+                    const z = i * 2;
+                    total += z;
+                }
+                return total;
+            })()
+            """).AsNumber();
+        Assert.Equal(6, untaken);
+
+        var secondIteration = engine.Evaluate("""
+            (function () {
+                try {
+                    for (let i = 0; i < 3; i++) {
+                        if (i === 1) z;
+                        const z = i;
+                    }
+                } catch (e) {
+                    return (e instanceof ReferenceError) + ':tdz';
+                }
+                return 'no-throw';
+            })()
+            """).AsString();
+        Assert.Equal("true:tdz", secondIteration);
+    }
+
+    [Fact]
+    public void ConstraintConfiguredEngineStillEnforcesInsideIfChainLoops()
+    {
+        var engine = new Engine(options => options.MaxStatements(50));
+        Assert.Throws<Jint.Runtime.StatementsCountOverflowException>(() =>
+            engine.Evaluate("(function () { var x = 0; for (var i = 0; i < 100000; i++) { if (i % 2 == 0) x += 1; else x -= 1; } })()"));
+    }
+
+    [Fact]
+    public void UsingDeclarationBodyDisposesPerIteration()
+    {
+        var engine = new Engine();
+        // using declarations are excluded from the tight shape; per-iteration dispose ordering
+        // must be untouched
+        var result = engine.Evaluate("""
+            (function () {
+                var log = [];
+                for (var i = 0; i < 2; i++) {
+                    using r = { [Symbol.dispose]() { log.push('d' + i); } };
+                    log.push('u' + i);
+                }
+                return log.join(',');
+            })()
+            """).AsString();
+
+        Assert.Equal("u0,d0,u1,d1", result);
+    }
 }
diff --git a/Jint/Runtime/Interpreter/Expressions/JintConditionalExpression.cs b/Jint/Runtime/Interpreter/Expressions/JintConditionalExpression.cs
index 8cb6a9670..7e9f0886f 100644
--- a/Jint/Runtime/Interpreter/Expressions/JintConditionalExpression.cs
+++ b/Jint/Runtime/Interpreter/Expressions/JintConditionalExpression.cs
@@ -17,8 +17,19 @@ public JintConditionalExpression(ConditionalExpression expression) : base(expres
 
     protected override object EvaluateInternal(EvaluationContext context)
     {
-        JsValue testValue;
         var suspendable = context.Engine?.ExecutionContext.Suspendable;
+
+        // In a plain synchronous frame nothing can suspend or resume mid-expression, so the test
+        // can take the unboxed boolean path (comparison lanes return raw bools) instead of
+        // materializing a JsValue only to feed TypeConverter.ToBoolean.
+        if (suspendable is null && context.Engine is not null)
+        {
+            return _test.GetBooleanValue(context)
+                ? _consequent.GetValue(context)
+                : _alternate.GetValue(context);
+        }
+
+        JsValue testValue;
         if (suspendable is { IsResuming: true }
             && suspendable.Data.TryGet(this, out LeftOperandSuspendData? suspendData))
         {
diff --git a/Jint/Runtime/Interpreter/Statements/JintBlockStatement.cs b/Jint/Runtime/Interpreter/Statements/JintBlockStatement.cs
index ae938f6b8..e1509e88c 100644
--- a/Jint/Runtime/Interpreter/Statements/JintBlockStatement.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintBlockStatement.cs
@@ -333,6 +333,32 @@ private void SetupDisposeSuspension(Engine engine, AsyncFunctionInstance asyncFn
     internal Completion ExecuteFlattenedContents(EvaluationContext context)
         => _statementList is not null ? _statementList.Execute(context) : ExecuteSingle(context);
 
+    /// <summary>
+    /// Tight-loop entry; see <see cref="JintStatement.ExecuteDiscarded"/>. Valid only for blocks
+    /// without lexical declarations (enforced by the enclosing loop's shape predicate), so no block
+    /// environment is created or attached. A statement after a deferred error must not run, so the
+    /// engine error slot is polled between statements; the caller polls after the last one.
+    /// </summary>
+    internal void ExecuteDiscardedContents(EvaluationContext context)
+    {
+        if (_singleStatement is not null)
+        {
+            _singleStatement.ExecuteDiscarded(context);
+            return;
+        }
+
+        var list = _statementList!;
+        var count = list.Count;
+        for (var i = 0; i < count; i++)
+        {
+            list.GetStatement(i).ExecuteDiscarded(context);
+            if (context.Engine._error is not null)
+            {
+                return;
+            }
+        }
+    }
+
     private Completion ExecuteSingle(EvaluationContext context)
     {
         Completion blockValue;
diff --git a/Jint/Runtime/Interpreter/Statements/JintEmptyStatement.cs b/Jint/Runtime/Interpreter/Statements/JintEmptyStatement.cs
index 2d1722434..2861d33f7 100644
--- a/Jint/Runtime/Interpreter/Statements/JintEmptyStatement.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintEmptyStatement.cs
@@ -12,4 +12,8 @@ protected override Completion ExecuteInternal(EvaluationContext context)
     {
         return new Completion(CompletionType.Normal, JsEmpty.Instance, _statement);
     }
+
+    internal override void ExecuteDiscarded(EvaluationContext context)
+    {
+    }
 }
diff --git a/Jint/Runtime/Interpreter/Statements/JintExpressionStatement.cs b/Jint/Runtime/Interpreter/Statements/JintExpressionStatement.cs
index ac4983ff3..51a70fad8 100644
--- a/Jint/Runtime/Interpreter/Statements/JintExpressionStatement.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintExpressionStatement.cs
@@ -46,7 +46,7 @@ protected override Completion ExecuteInternal(EvaluationContext context)
     /// Callers guarantee a non-suspendable frame, no constraint/debug checks and dead
     /// completion values; expression evaluation still tracks the current node for errors.
     /// </summary>
-    internal void ExecuteDiscarded(EvaluationContext context)
+    internal override void ExecuteDiscarded(EvaluationContext context)
     {
         if (_expressionCanDiscard)
         {
diff --git a/Jint/Runtime/Interpreter/Statements/JintForStatement.cs b/Jint/Runtime/Interpreter/Statements/JintForStatement.cs
index 03591f12d..707299706 100644
--- a/Jint/Runtime/Interpreter/Statements/JintForStatement.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintForStatement.cs
@@ -21,13 +21,17 @@ internal sealed class JintForStatement : JintStatement<ForStatement>
     private readonly ProbablyBlockStatement _body;
     private readonly List<Key>? _boundNames;
 
-    // Tight loop: an expression-statements-only body (single statement, empty statement or a
-    // brace block of them) cannot break/continue/label/declare, so when the frame additionally
-    // cannot suspend, debug or observe completion values, the per-iteration bookkeeping is dead.
-    // The references reuse the body's own handler instances — building duplicates here would
-    // allocate a fresh subtree every time this handler is constructed.
+    // Tight loop: a body of expression statements, var/let/const declarations and if/else chains
+    // over such statements cannot break/continue/label/return, so every body completion is
+    // structurally Normal and, when the frame additionally cannot suspend, debug or observe
+    // completion values, the per-iteration bookkeeping is dead. Bodies with lexical declarations
+    // additionally require the flattened pooled environment (their slots live there); without it
+    // the generic path creates the per-iteration block environment. The references reuse the
+    // body's own handler instances — building duplicates here would allocate a fresh subtree
+    // every time this handler is constructed.
     private readonly bool _tightBodyEligible;
-    private readonly JintExpressionStatement? _tightSingleStatement;
+    private readonly bool _tightBodyHasLexicalDeclarations;
+    private readonly JintStatement? _tightSingleStatement;
     private readonly JintStatementList? _tightBodyList;
 
     // Body-lexical flattening: when the body block's let/const bindings are slot-eligible
@@ -140,43 +144,97 @@ public JintForStatement(ForStatement statement) : base(statement)
             if (_body.BlockStatement is { } bodyBlock)
             {
                 // single-statement blocks live in SingleStatement, larger (and empty) ones in the list
-                _tightSingleStatement = bodyBlock.SingleStatement as JintExpressionStatement;
+                _tightSingleStatement = bodyBlock.SingleStatement;
                 _tightBodyList = _tightSingleStatement is null ? bodyBlock.StatementList : null;
+                _tightBodyHasLexicalDeclarations = bodyBlock.State.Declarations.Count > 0;
             }
-            else
+            else if (_body.Statement is not JintEmptyStatement)
             {
-                // an EmptyStatement body leaves both references null
-                _tightSingleStatement = _body.Statement as JintExpressionStatement;
+                // an EmptyStatement body leaves both references null (nothing to run per iteration)
+                _tightSingleStatement = _body.Statement;
             }
         }
     }
 
     /// <summary>
-    /// A tight-loop body is an expression statement, an empty statement, or a brace block
-    /// containing only expression statements. Any other statement type — declarations, control
-    /// flow, labels, debugger — disqualifies the body.
+    /// A tight-loop body contains only statements whose completions are structurally Normal:
+    /// expression statements, empty statements, var/let/const declarations, and if/else chains
+    /// over such statements (including declaration-free brace blocks). Control flow that routes
+    /// completions (break/continue/return/labels/loops/switch/try), other declarations, and
+    /// AnnexB function-declaration branches all disqualify the body.
     /// </summary>
     private static bool IsTightBodyShape(Statement body)
     {
-        if (body is ExpressionStatement or EmptyStatement)
+        if (body is NestedBlockStatement block)
         {
+            foreach (var statement in block.Body)
+            {
+                if (!IsTightStatement(statement))
+                {
+                    return false;
+                }
+            }
+
             return true;
         }
 
-        if (body is not NestedBlockStatement block)
+        return IsTightStatement(body);
+    }
+
+    private static bool IsTightStatement(Statement statement)
+    {
+        switch (statement.Type)
+        {
+            case NodeType.ExpressionStatement:
+            case NodeType.EmptyStatement:
+                return true;
+
+            case NodeType.VariableDeclaration:
+                // using/await using declarations register dispose resources — not tight
+                return ((VariableDeclaration) statement).Kind
+                    is VariableDeclarationKind.Var
+                    or VariableDeclarationKind.Let
+                    or VariableDeclarationKind.Const;
+
+            case NodeType.IfStatement:
+                var ifStatement = (IfStatement) statement;
+                return IsTightBranch(ifStatement.Consequent)
+                    && (ifStatement.Alternate is null || IsTightBranch(ifStatement.Alternate));
+
+            default:
+                return false;
+        }
+    }
+
+    private static bool IsTightBranch(Statement branch)
+    {
+        // sloppy-mode `if (c) function f() {}` takes the AnnexB var-scope copy path at runtime
+        if (branch.Type == NodeType.FunctionDeclaration)
         {
             return false;
         }
 
-        foreach (var statement in block.Body)
+        if (branch is NestedBlockStatement block)
         {
-            if (statement is not ExpressionStatement)
+            foreach (var statement in block.Body)
             {
-                return false;
+                // a lexical declaration would require the nested block's own environment
+                if (statement.Type is NodeType.ClassDeclaration or NodeType.FunctionDeclaration
+                    || statement is VariableDeclaration { Kind: not VariableDeclarationKind.Var })
+                {
+                    return false;
+                }
+
+                if (!IsTightStatement(statement))
+                {
+                    return false;
+                }
             }
+
+            return true;
         }
 
-        return true;
+        return IsTightStatement(branch);
     }
 
     protected override Completion ExecuteInternal(EvaluationContext context)
@@ -455,9 +513,10 @@ private Completion ForBodyEvaluation(EvaluationContext context, JsValue initialV
             && !context.ShouldRunBeforeExecuteStatementChecks
             && !context.DebugMode
             && (!_shouldCreatePerIterationEnvironment || _canReuseIterationEnvironment)
+            && (!_tightBodyHasLexicalDeclarations || flattenActive)
             && context.Engine.ExecutionContext.Suspendable is null)
         {
-            return TightForBody(context);
+            return TightForBody(context, flattenActive);
         }
 
         if (!resumeUpdateOnce && _shouldCreatePerIterationEnvironment && !_canReuseIterationEnvironment)
@@ -575,39 +634,48 @@ private Completion ForBodyEvaluation(EvaluationContext context, JsValue initialV
     }
 
     /// <summary>
-    /// The bare test → body-expressions → update cycle. Exceptions propagate to the enclosing
+    /// The bare test → body-statements → update cycle. Exceptions propagate to the enclosing
     /// statement list exactly as on the generic path (ForBodyEvaluation catches nothing); the
     /// loop's Normal completion value is dead by the caller's gate, so Undefined stands in.
     /// Deferred errors surface as Engine._error instead of a .NET throw; the statement list
-    /// converts them per statement, and so must the tight loop.
+    /// converts them per statement, and so must the tight loop. Under flattening the pooled
+    /// loop environment carries the body's slots: their TDZ is re-established per iteration
+    /// before the body statements run, mirroring the generic flattened arm.
     /// </summary>
     [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
-    private Completion TightForBody(EvaluationContext context)
+    private Completion TightForBody(EvaluationContext context, bool flattenActive)
     {
         var test = _test!;
         var increment = _increment;
         var single = _tightSingleStatement;
         var list = _tightBodyList;
+        var engine = context.Engine;
 
         while (test.GetBooleanValue(context))
         {
+            if (flattenActive)
+            {
+                var env = (DeclarativeEnvironment) engine.ExecutionContext.LexicalEnvironment;
+                ResetBodySlotRange(env._slots!, _loopSlotTemplates!, _flattenedHeaderSlotCount);
+            }
+
             if (single is not null)
             {
                 single.ExecuteDiscarded(context);
-                if (context.Engine._error is not null)
+                if (engine._error is not null)
                 {
-                    return JintStatementList.HandleError(context.Engine, single);
+                    return JintStatementList.HandleError(engine, single);
                 }
             }
             else if (list is not null)
             {
                 for (var i = 0; i < list.Count; i++)
                 {
-                    var statement = (JintExpressionStatement) list.GetStatement(i);
+                    var statement = list.GetStatement(i);
                     statement.ExecuteDiscarded(context);
-                    if (context.Engine._error is not null)
+                    if (engine._error is not null)
                     {
-                        return JintStatementList.HandleError(context.Engine, statement);
+                        return JintStatementList.HandleError(engine, statement);
                     }
                 }
             }
diff --git a/Jint/Runtime/Interpreter/Statements/JintIfStatement.cs b/Jint/Runtime/Interpreter/Statements/JintIfStatement.cs
index 05d1004b0..44d382b25 100644
--- a/Jint/Runtime/Interpreter/Statements/JintIfStatement.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintIfStatement.cs
@@ -76,6 +76,34 @@ protected override Completion ExecuteInternal(EvaluationContext context)
         return result.UpdateEmpty(JsValue.Undefined);
     }
 
+    /// <summary>
+    /// Tight-loop entry. The enclosing loop's shape predicate guarantees neither branch is a
+    /// FunctionDeclaration (no AnnexB handling) and the frame cannot suspend (no resume probes);
+    /// the branch statements are themselves tight, so no Completion needs materializing.
+    /// A deferred error signalled by the test must suppress the branch — the caller converts it.
+    /// </summary>
+    internal override void ExecuteDiscarded(EvaluationContext context)
+    {
+        if (_test.GetBooleanValue(context))
+        {
+            if (context.Engine._error is not null)
+            {
+                return;
+            }
+
+            _statementConsequent.ExecuteDiscarded(context);
+        }
+        else
+        {
+            if (context.Engine._error is not null)
+            {
+                return;
+            }
+
+            _alternate?.ExecuteDiscarded(context);
+        }
+    }
+
     /// <summary>
     /// B.3.4: When an IfStatement's consequent or alternate is a FunctionDeclaration
     /// in sloppy mode, treat it as if wrapped in a block: create a block-scoped binding
diff --git a/Jint/Runtime/Interpreter/Statements/JintStatement.cs b/Jint/Runtime/Interpreter/Statements/JintStatement.cs
index e3e9cf879..399a5c968 100644
--- a/Jint/Runtime/Interpreter/Statements/JintStatement.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintStatement.cs
@@ -39,6 +39,20 @@ public Completion Execute(EvaluationContext context)
 
     protected abstract Completion ExecuteInternal(EvaluationContext context);
 
+    /// <summary>
+    /// Tight-loop entry: executes the statement for side effects only, skipping the per-statement
+    /// ceremony (PrepareFor, constraint checks, Completion materialization) where an override can
+    /// prove it dead. Callers guarantee a non-suspendable frame, no constraint/debug checks, dead
+    /// completion values, and a statement shape vetted by <see cref="JintForStatement"/>'s tight-body
+    /// predicate (no break/continue/return/labels, so only Normal completions can occur). Deferred
+    /// errors surface via <see cref="Engine._error"/>, which the caller polls after each statement.
+    /// The base implementation falls back to the full <see cref="Execute"/> ceremony.
+    /// </summary>
+    internal virtual void ExecuteDiscarded(EvaluationContext context)
+    {
+        Execute(context);
+    }
+
     public ref readonly SourceLocation Location => ref _statement.LocationRef;
 
     protected internal static JintStatement Build(Statement statement)
diff --git a/Jint/Runtime/Interpreter/Statements/JintVariableDeclaration.cs b/Jint/Runtime/Interpreter/Statements/JintVariableDeclaration.cs
index 64c94868d..eafbc835c 100644
--- a/Jint/Runtime/Interpreter/Statements/JintVariableDeclaration.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintVariableDeclaration.cs
@@ -87,6 +87,20 @@ public JintVariableDeclaration(VariableDeclaration statement) : base(statement)
         }
     }
 
+    /// <summary>
+    /// Tight-loop entry; see <see cref="JintStatement.ExecuteDiscarded"/>. Declarations complete
+    /// with an Empty Normal value on every path, so only the Execute wrapper ceremony is skipped;
+    /// the current node still needs tracking for error locations. Skipping PrepareFor is safe:
+    /// <see cref="EvaluationContext.Completion"/> is written nowhere but PrepareFor (never abrupt)
+    /// and a stale <see cref="EvaluationContext.Target"/> is only consumed under Break/Continue
+    /// completions, which the tight shape excludes.
+    /// </summary>
+    internal override void ExecuteDiscarded(EvaluationContext context)
+    {
+        context.LastSyntaxElement = _statement;
+        ExecuteInternal(context);
+    }
+
     protected override Completion ExecuteInternal(EvaluationContext context)
     {
         var engine = context.Engine;
diff --git a/Jint/Runtime/Interpreter/Statements/ProbablyBlockStatement.cs b/Jint/Runtime/Interpreter/Statements/ProbablyBlockStatement.cs
index de2e5539d..cfaee018f 100644
--- a/Jint/Runtime/Interpreter/Statements/ProbablyBlockStatement.cs
+++ b/Jint/Runtime/Interpreter/Statements/ProbablyBlockStatement.cs
@@ -38,4 +38,22 @@ public Completion Execute(EvaluationContext context)
 
         return _statement!.Execute(context);
     }
+
+    /// <summary>
+    /// Tight-loop entry; see <see cref="JintStatement.ExecuteDiscarded"/>. The enclosing loop's
+    /// shape predicate admits block targets only when they carry no lexical declarations, so the
+    /// block-env ceremony is skipped along with the per-statement bookkeeping.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ExecuteDiscarded(EvaluationContext context)
+    {
+        if (_blockStatement is not null)
+        {
+            _blockStatement.ExecuteDiscardedContents(context);
+        }
+        else
+        {
+            _statement!.ExecuteDiscarded(context);
+        }
+    }
 }