UnifiedBytecodeProductionInvocationTests.cs

using System.IO;
using Asynkron.JsEngine;
using Asynkron.JsEngine.Ast;
using Xunit.Abstractions;

namespace Asynkron.JsEngine.Tests;

[Category(TestCategories.RuntimeSemantics)]
public sealed class UnifiedBytecodeProductionInvocationTests(ITestOutputHelper output) : InternalTestBase(output)
{
    private const string UnifiedBytecodeProductionFastPathLog = "unified-bytecode-production-fast-path";
    private const string SimpleIrParameterNumberBinaryFastPathLog =
        "simple-ir-parameter-number-binary-fast-path";
    private const string SimpleIrParameterNumberBinaryChainFastPathLog =
        "simple-ir-parameter-number-binary-chain-fast-path";

    [Fact(Timeout = 5000)]
    public async Task LinearSlotReturnFunction_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function passThrough(x) {
                var y = x;
                return y;
            }

            passThrough(42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=passThrough argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LocalLiteralReturnFunction_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readLocal() {
                var y = 7;
                return y;
            }

            readLocal();
            """);

        Assert.Equal(7d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readLocal argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedFunctionDeclaration_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function outer() {
                function inner() {
                    return 42;
                }

                return inner();
            }

            outer();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=outer argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ParameterVarDeclarationWithoutInitializer_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function parameterVar(value) {
                var value;
                return value;
            }

            parameterVar(42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=parameterVar argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedFunctionExpressionParameterCollision_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var result = (function same(same) {
                return same;
            })(42);

            result;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=same argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedClassDeclaration_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function create(seed) {
                class Local {
                    static {
                        seed = seed + 1;
                    }
                }

                return seed;
            }

            create(41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=create argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleObjectDestructuring_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readAb(source) {
                var { a, b } = source;
                return a + b;
            }

            readAb({ a: 40, b: 2 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readAb argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedStaticBindingDeclaration_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function destructure(source) {
                {
                    let { nested: { value } } = source;
                    return value;
                }
            }

            destructure({ nested: { value: 42 } });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=destructure argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectDestructuring_PreservesPropertyReadOrder_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var order = [];
            function readAb(source) {
                var { a, b } = source;
                return a + b;
            }

            var src = {};
            Object.defineProperty(src, "a", {
                get: function () { order.push("a"); return 1; },
                enumerable: true
            });
            Object.defineProperty(src, "b", {
                get: function () { order.push("b"); return 2; },
                enumerable: true
            });

            var sum = readAb(src);
            [sum, order.join(",")];
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(3d, steps.Items[0].AsDouble());
        Assert.Equal("a,b", steps.Items[1].AsString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readAb argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectDestructuringRest_CollectsRemainingProperties_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readRest(source) {
                var { a, ...rest } = source;
                return rest.c;
            }

            readRest({ a: 1, b: 2, c: 3 });
            """);

        Assert.Equal(3d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readRest argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectDestructuringNullSource_ThrowsTypeError_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readAb(source) {
                var { a } = source;
                return a;
            }

            var captured = false;
            try {
                readAb(null);
            } catch (error) {
                captured = error instanceof TypeError;
            }

            captured;
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readAb argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectDestructuringGetterThrow_PropagatesAndCleansUp_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readAb(source) {
                var { a, b } = source;
                return a + b;
            }

            var src = {
                a: 1,
                get b() { throw new RangeError("boom"); }
            };

            var message = null;
            try {
                readAb(src);
            } catch (error) {
                message = error instanceof RangeError ? error.message : "wrong";
            }

            message;
            """);

        Assert.Equal("boom", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readAb argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task AssignmentDestructuringComputedDefault_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function assignComputedDefault(source, key) {
                var value = 0;
                ({ [key]: value = 5 } = source);
                return value;
            }

            assignComputedDefault({}, "picked");
            """);

        Assert.Equal(5d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=assignComputedDefault argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task AssignmentDestructuringValue_DoesNotInferBindingTargetName_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function assignValueName(source) {
                var assigned;
                ({ value: assigned } = source);
                return assigned.name;
            }

            var payload = (0, function() {});
            assignValueName({ value: payload });
            """);

        Assert.Equal("", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=assignValueName argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task AssignmentDestructuringGetterThrow_PreservesPartialWriteAfterCaughtThrow_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function probe(source) {
                var a = 0;
                var b = 0;
                try {
                    ({ a, b } = source);
                } catch {
                    return a;
                }

                return -1;
            }

            probe({
                a: 1,
                get b() { throw new RangeError("boom"); }
            });
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=probe argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task AssignmentDestructuringIteratorValueThrow_ClosesIteratorAndPreservesPartialWrite_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function probe(iterable) {
                var a = 0;
                var b = 0;
                try {
                    [a, b] = iterable;
                } catch {
                    return a;
                }

                return -1;
            }

            var closed = false;
            var iterable = {
                [Symbol.iterator]: function () {
                    var step = 0;
                    return {
                        next: function () {
                            step = step + 1;
                            if (step === 1) {
                                return { value: 1, done: false };
                            }

                            return {
                                get value() { throw new RangeError("boom"); },
                                done: false
                            };
                        },
                        return: function () {
                            closed = true;
                            return {};
                        }
                    };
                }
            };

            var observed = probe(iterable);
            [observed, closed];
            """);

        var observed = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(1d, observed.Items[0].AsDouble());
        Assert.True(observed.Items[1].AsBoolean());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=probe argc=1",
                StringComparison.Ordinal));
    }

    [Theory(Timeout = 5000)]
    [InlineData(
        """
        function readArrayDefault(values) {
            var [first = 5] = values;
            return first;
        }

        readArrayDefault([]);
        """,
        "readArrayDefault",
        5d)]
    [InlineData(
        """
        function readObjectDefault(source) {
            var { a = 5 } = source;
            return a;
        }

        readObjectDefault({});
        """,
        "readObjectDefault",
        5d)]
    [InlineData(
        """
        function readObjectComputed(source, key) {
            var { [key]: value } = source;
            return value;
        }

        readObjectComputed({ picked: 7 }, "picked");
        """,
        "readObjectComputed",
        7d)]
    public async Task DeclarationDestructuringDescriptorShapes_UseUnifiedBytecodeProductionFastPath(
        string source,
        string functionName,
        object expected)
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate(source);

        Assert.Equal(expected, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                $"unified-bytecode-production-fast-path func={functionName}",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleGeneratorYieldSend_UsesResumableUnifiedBytecodeFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function* gen(input) {
                var x = yield input;
                return x + 1;
            }

            var iterator = gen(10);
            var first = iterator.next();
            var second = iterator.next(41);
            [first.value, first.done, second.value, second.done];
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(10d, steps.Items[0].AsDouble());
        Assert.False(steps.Items[1].AsBoolean());
        Assert.Equal(42d, steps.Items[2].AsDouble());
        Assert.True(steps.Items[3].AsBoolean());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-generator-fast-path func=gen argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ParenthesizedShortCircuitYield_UsesResumableUnifiedBytecodeFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function* gen() {
                return yield ("left" && "right");
            }

            var iterator = gen();
            var first = iterator.next();
            var second = iterator.next("resume");
            [first.value, first.done, second.value, second.done];
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal("right", steps.Items[0].AsString());
        Assert.False(steps.Items[1].AsBoolean());
        Assert.Equal("resume", steps.Items[2].AsString());
        Assert.True(steps.Items[3].AsBoolean());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-generator-fast-path func=gen argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleAsyncAwaitReturn_UsesResumableUnifiedBytecodeFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.EvaluateAndAwait("""
            var asyncResult = undefined;
            async function run(input) {
                await input;
                return await 41;
            }

            run(1).then(value => asyncResult = value);
            asyncResult;
            """);

        Assert.Equal(41d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-async-fast-path func=run argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleGeneratorYieldStar_UsesResumableUnifiedBytecodeFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function* relay(values) {
                yield* values;
            }

            var iterator = relay([3]);
            var first = iterator.next();
            var second = iterator.next();
            [first.value, first.done, second.value, second.done];
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(3d, steps.Items[0].AsDouble());
        Assert.False(steps.Items[1].AsBoolean());
        Assert.Equal(Symbol.Undefined, steps.Items[2]);
        Assert.True(steps.Items[3].AsBoolean());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-generator-fast-path func=relay",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task GeneratorYieldStar_PreservesIterableSlotAfterDelegation()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function* relay(values) {
                yield* values;
                return values;
            }

            var array = [3];
            var iterator = relay(array);
            var first = iterator.next();
            var second = iterator.next();
            [first.value, first.done, second.value === array, second.done];
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(3d, steps.Items[0].AsDouble());
        Assert.False(steps.Items[1].AsBoolean());
        Assert.True(steps.Items[2].AsBoolean());
        Assert.True(steps.Items[3].AsBoolean());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-generator-fast-path func=relay",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleGeneratorYieldStar_ReturnDelegatesThroughResumableUnifiedBytecode()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function* outer(delegated) {
                return yield* delegated;
            }

            var calls = [];
            var delegated = {
                [Symbol.iterator]() {
                    return {
                        next() {
                            calls.push("next");
                            return { value: "first", done: false };
                        },
                        return(value) {
                            calls.push("return:" + value);
                            return { value: "closed:" + value, done: true };
                        }
                    };
                }
            };

            var iterator = outer(delegated);
            var first = iterator.next();
            var second = iterator.return("stop");
            [first.value, first.done, second.value, second.done, calls.join(",")];
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal("first", steps.Items[0].AsString());
        Assert.False(steps.Items[1].AsBoolean());
        Assert.Equal("closed:stop", steps.Items[2].AsString());
        Assert.True(steps.Items[3].AsBoolean());
        Assert.Equal("next,return:stop", steps.Items[4].AsString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-generator-fast-path func=outer",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleGeneratorYieldStar_ThrowDelegatesThroughResumableUnifiedBytecode()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function* outer(delegated) {
                return yield* delegated;
            }

            var calls = [];
            var delegated = {
                [Symbol.iterator]() {
                    return {
                        next() {
                            calls.push("next");
                            return { value: "first", done: false };
                        },
                        throw(value) {
                            calls.push("throw:" + value);
                            return { value: "handled:" + value, done: true };
                        }
                    };
                }
            };

            var iterator = outer(delegated);
            var first = iterator.next();
            var second = iterator.throw("boom");
            [first.value, first.done, second.value, second.done, calls.join(",")];
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal("first", steps.Items[0].AsString());
        Assert.False(steps.Items[1].AsBoolean());
        Assert.Equal("handled:boom", steps.Items[2].AsString());
        Assert.True(steps.Items[3].AsBoolean());
        Assert.Equal("next,throw:boom", steps.Items[4].AsString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-generator-fast-path func=outer",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task AsyncGeneratorYieldStar_ReturnDelegatesThroughIrAndDeclinesResumableUnifiedBytecode()
    {
        await using var engine = CreateEngine();
        var result = await engine.EvaluateAndAwait("""
            var asyncResult = undefined;

            async function* outer(delegated) {
                return yield* delegated;
            }

            var calls = [];
            var delegated = {
                [Symbol.asyncIterator]() {
                    return {
                        async next() {
                            calls.push("next");
                            return { value: "first", done: false };
                        },
                        async return(value) {
                            calls.push("return:" + value);
                            return { value: "closed:" + value, done: true };
                        }
                    };
                }
            };

            async function run() {
                var iterator = outer(delegated);
                var first = await iterator.next();
                var second = await iterator.return("stop");
                return [first.value, first.done, second.value, second.done, calls.join(",")];
            }

            run().then(value => asyncResult = value);
            asyncResult;
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal("first", steps.Items[0].AsString());
        Assert.False(steps.Items[1].AsBoolean());
        Assert.Equal("closed:stop", steps.Items[2].AsString());
        Assert.True(steps.Items[3].AsBoolean());
        Assert.Equal("next,return:stop", steps.Items[4].AsString());
        Assert.DoesNotContain(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-generator-fast-path func=outer",
                StringComparison.Ordinal));
        Assert.DoesNotContain(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-async-fast-path func=outer",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task AsyncGeneratorYieldStar_ThrowDelegatesThroughIrAndDeclinesResumableUnifiedBytecode()
    {
        await using var engine = CreateEngine();
        var result = await engine.EvaluateAndAwait("""
            var asyncResult = undefined;

            async function* outer(delegated) {
                return yield* delegated;
            }

            var calls = [];
            var delegated = {
                [Symbol.asyncIterator]() {
                    return {
                        async next() {
                            calls.push("next");
                            return { value: "first", done: false };
                        },
                        async throw(value) {
                            calls.push("throw:" + value);
                            return { value: "handled:" + value, done: true };
                        }
                    };
                }
            };

            async function run() {
                var iterator = outer(delegated);
                var first = await iterator.next();
                var second = await iterator.throw("boom");
                return [first.value, first.done, second.value, second.done, calls.join(",")];
            }

            run().then(value => asyncResult = value);
            asyncResult;
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal("first", steps.Items[0].AsString());
        Assert.False(steps.Items[1].AsBoolean());
        Assert.Equal("handled:boom", steps.Items[2].AsString());
        Assert.True(steps.Items[3].AsBoolean());
        Assert.Equal("next,throw:boom", steps.Items[4].AsString());
        Assert.DoesNotContain(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-generator-fast-path func=outer",
                StringComparison.Ordinal));
        Assert.DoesNotContain(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-resumable-async-fast-path func=outer",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task MissingArgument_InitializesParameterSlotToUndefined()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function passThrough(x) {
                var y = x;
                return y;
            }

            passThrough();
            """);

        Assert.Equal(Symbol.Undefined, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=passThrough argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task WithDynamicIdentifierOperations_UseUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function run(scope) {
                with (scope) {
                    value = value + 2;
                    ++count;
                    missingType = typeof missing;
                    deleteResult = delete removable;
                    removableType = typeof removable;
                    return value + ":" +
                        count + ":" +
                        missingType + ":" +
                        deleteResult + ":" +
                        removableType;
                }
            }

            run({
                value: 1,
                count: 4,
                removable: 9,
                missingType: "",
                deleteResult: false,
                removableType: ""
            });
            """);

        Assert.Equal("3:5:undefined:true:undefined", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=run argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task WithFunctionVarInitializer_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function run(scope) {
                var add = 2;
                with (scope) {
                    return value + add;
                }
            }

            run({ value: 40 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=run argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task WithVarInitializer_PreResolvesBindingBeforeInitializerOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var scope = new Proxy(
                { value: 1, hide: 0 },
                {
                    has(target, key) {
                        return key === "value" ? target.hide === 0 : key in target;
                    }
                });

            function run(scope) {
                with (scope) {
                    var value = (++hide, 42);
                    return value;
                }
            }

            run(scope) + ":" + scope.value + ":" + scope.hide;
            """);

        Assert.Equal("undefined:42:1", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=run argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedFunctionVarDeclaration_IsHoistedAcrossOuterWithWhenThrowingOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function run(scope) {
                var result = "result";
                var f = function() {
                    throw value;
                    var value = "local";
                };

                try {
                    with (scope) {
                        f();
                    }
                } catch (error) {
                    result = error;
                }

                return result;
            }

            run({ value: "scope" });
            """);

        Assert.Equal(Symbol.Undefined, result);
    }

    [Fact(Timeout = 5000)]
    public async Task WithThenOutsideDynamicIdentifier_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var externalValue = 41;

            function run(scope) {
                with (scope) {
                    value = value + 1;
                }

                return externalValue + 1;
            }

            run({ value: 1 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=run argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OrdinaryGlobalDynamicIdentifierOperations_UseUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            externalValue = 1;
            globalCount = 4;
            removable = 9;

            function run(delta) {
                externalValue = externalValue + delta;
                ++globalCount;
                var missingType = typeof missing;
                var deleteResult = delete removable;
                var removableType = typeof removable;
                return externalValue + ":" +
                    globalCount + ":" +
                    missingType + ":" +
                    deleteResult + ":" +
                    removableType;
            }

            run(2) + ":" + externalValue + ":" + globalCount + ":" + typeof removable;
            """);

        Assert.Equal("3:5:undefined:true:undefined:3:5:undefined", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=run argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DirectEvalDeclarationDynamicLookup_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function run() {
                eval("var value = 41;");
                return value + 1;
            }

            run();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=run argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task WithDynamicIdentifierCallTarget_UsesWithReceiverOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function run(scope) {
                with (scope) {
                    return finish();
                }
            }

            run({
                marker: 17,
                finish: function() {
                    return this.marker;
                }
            });
            """);

        Assert.Equal(17d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=run argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task WithDynamicIdentifierLookup_RespectsProxyAndUnscopablesOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var log = [];
            var hidden = 40;

            function run(scope) {
                with (scope) {
                    return hidden + visible;
                }
            }

            var target = {
                hidden: 1,
                visible: 2
            };
            target[Symbol.unscopables] = { hidden: true };

            var proxy = new Proxy(target, {
                has: function(obj, prop) {
                    log.push("has:" + String(prop));
                    return prop in obj;
                },
                get: function(obj, prop, receiver) {
                    log.push("get:" + String(prop));
                    return Reflect.get(obj, prop, receiver);
                }
            });

            run(proxy) + ":" +
                (log.indexOf("has:hidden") >= 0) + ":" +
                (log.indexOf("has:visible") >= 0) + ":" +
                (log.indexOf("get:visible") >= 0);
            """);

        Assert.Equal("42:true:true:true", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=run argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryCatch_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function recover() {
                try {
                    throw 40;
                } catch (e) {
                    return e + 2;
                }
            }

            recover();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=recover argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryCatch_CatchBindingDoesNotLeakAfterCatchOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function leak() {
                try {
                    throw 7;
                } catch (e) {
                }

                return typeof e;
            }

            leak();
            """);

        Assert.Equal("undefined", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=leak argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryCatch_CatchBindingDirectReadAfterCatchThrowsReferenceErrorOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function probe() {
                try {
                    throw 7;
                } catch (e) {
                }

                try {
                    return e;
                } catch (error) {
                    return error.name;
                }
            }

            probe();
            """);

        Assert.Equal("ReferenceError", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=probe argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryFinally_ReturnFromFinallyReplacesPriorReturnOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function replaceReturn() {
                try {
                    return 1;
                } finally {
                    return 2;
                }
            }

            replaceReturn();
            """);

        Assert.Equal(2d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=replaceReturn argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryFinally_NestedReturnThroughFinallyClearsOperandStackOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function replaceNestedReturn() {
                try {
                    return 3;
                } finally {
                    try {
                        return (10 + 20) + (30 + 40);
                    } finally {
                        (1 + 2) + (3 + 4);
                    }
                }
            }

            replaceNestedReturn();
            """);

        Assert.Equal(100d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=replaceNestedReturn argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryFinally_ThrowFromFinallyReplacesPriorThrowOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function replaceThrow() {
                try {
                    try {
                        throw 1;
                    } finally {
                        throw 2;
                    }
                } catch (e) {
                    return e;
                }
            }

            replaceThrow();
            """);

        Assert.Equal(2d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=replaceThrow argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryFinally_BreakThroughFinallyUsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function breakFinally(n) {
                var marker = 0;
                while (n > 0) {
                    try {
                        break;
                    } finally {
                        marker = marker + 10;
                    }
                }

                return marker;
            }

            breakFinally(2);
            """);

        Assert.Equal(10d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=breakFinally argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryFinally_ContinueThroughFinallyUsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function continueFinally(n) {
                var i = 0;
                var marker = 0;
                while (i < n) {
                    i = i + 1;
                    try {
                        continue;
                    } finally {
                        marker = marker + 10;
                    }
                }

                return marker + i;
            }

            continueFinally(2);
            """);

        Assert.Equal(22d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=continueFinally argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ForOfNestedInnerBreak_DoesNotCloseOuterIteratorBeforeReturnExpressionOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function makeIterable(closeValue, box) {
                return {
                    [Symbol.iterator]: function() {
                        var seen = false;
                        return {
                            next: function() {
                                if (seen) {
                                    return { done: true };
                                }

                                seen = true;
                                return { done: false, value: closeValue };
                            },
                            return: function() {
                                box.value = box.value + closeValue;
                                return {};
                            }
                        };
                    }
                };
            }

            function probe(outer, inner, box) {
                for (var outerValue of outer) {
                    for (var innerValue of inner) {
                        break;
                    }

                    return box.value;
                }

                return -1;
            }

            var box = { value: 0 };
            var result = probe(makeIterable(10, box), makeIterable(1, box), box);
            result + ":" + box.value;
            """);

        Assert.Equal("1:11", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=probe argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LabeledBlockBreak_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function labeledBlock(flag) {
                var total = 0;
                block: {
                    total = total + 1;
                    if (flag) {
                        break block;
                    }

                    total = total + 10;
                }

                return total;
            }

            labeledBlock(true);
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=labeledBlock argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LabeledBreakInLoop_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function labeledBreak(n) {
                outer: while (n > 0) {
                    break outer;
                }

                return n;
            }

            labeledBreak(3);
            """);

        Assert.Equal(3d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=labeledBreak argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LabeledContinueInLoop_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function labeledContinue(n) {
                var total = 0;
                outer: while (n > 0) {
                    n = n - 1;
                    continue outer;
                    total = total + 1;
                }

                return total;
            }

            labeledContinue(3);
            """);

        // continue outer skips the post-continue increment on every iteration, so total stays 0.
        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=labeledContinue argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LabeledBreakOutOfForOf_ClosesDriverOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function makeIterable(closeValue, box) {
                return {
                    [Symbol.iterator]: function() {
                        var i = 0;
                        return {
                            next: function() {
                                i = i + 1;
                                return { done: i > 5, value: i };
                            },
                            return: function() {
                                box.value = box.value + closeValue;
                                return {};
                            }
                        };
                    }
                };
            }

            function probe(source, box) {
                outer: for (var value of source) {
                    break outer;
                }

                return box.value;
            }

            var box = { value: 0 };
            var result = probe(makeIterable(7, box), box);
            result + ":" + box.value;
            """);

        // Labeled break out of the for-of closes its iterator (box += 7) before probe returns.
        Assert.Equal("7:7", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=probe argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LabeledContinueAcrossNestedForOf_ClosesInnerIteratorOnly()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function makeOuterIterable(box) {
                return {
                    [Symbol.iterator]: function() {
                        var i = 0;
                        return {
                            next: function() {
                                i = i + 1;
                                return { done: i > 2, value: i };
                            },
                            return: function() {
                                box.outerCloses = box.outerCloses + 1;
                                return {};
                            }
                        };
                    }
                };
            }

            function makeInnerIterable(box) {
                return {
                    [Symbol.iterator]: function() {
                        var seen = false;
                        return {
                            next: function() {
                                if (seen) {
                                    return { done: true };
                                }

                                seen = true;
                                return { done: false, value: 1 };
                            },
                            return: function() {
                                box.innerCloses = box.innerCloses + 1;
                                return {};
                            }
                        };
                    }
                };
            }

            function probe(outer, inner, box) {
                outerLabel: for (var x of outer) {
                    for (var y of inner) {
                        continue outerLabel;
                    }
                }

                return 0;
            }

            var box = { innerCloses: 0, outerCloses: 0 };
            probe(makeOuterIterable(box), makeInnerIterable(box), box);
            (box.innerCloses * 10) + box.outerCloses;
            """);

        Assert.Equal(20d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=probe argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LabeledBreakAcrossNestedForOf_ClosesExitedIteratorsInnerToOuter()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function makeOuterIterable(box) {
                return {
                    [Symbol.iterator]: function() {
                        var seen = false;
                        return {
                            next: function() {
                                if (seen) {
                                    return { done: true };
                                }

                                seen = true;
                                return { done: false, value: 1 };
                            },
                            return: function() {
                                box.order = box.order + "o";
                                return {};
                            }
                        };
                    }
                };
            }

            function makeInnerIterable(box) {
                return {
                    [Symbol.iterator]: function() {
                        var seen = false;
                        return {
                            next: function() {
                                if (seen) {
                                    return { done: true };
                                }

                                seen = true;
                                return { done: false, value: 1 };
                            },
                            return: function() {
                                box.order = box.order + "i";
                                return {};
                            }
                        };
                    }
                };
            }

            function probe(outer, inner, box) {
                outerLabel: for (var x of outer) {
                    for (var y of inner) {
                        break outerLabel;
                    }
                }

                return box.order;
            }

            var box = { order: "" };
            probe(makeOuterIterable(box), makeInnerIterable(box), box);
            """);

        Assert.Equal("io", result);
    }

    [Fact(Timeout = 5000)]
    public async Task LabeledContinueAcrossNestedForIn_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function probe(outer, inner) {
                var total = 0;
                outerLabel: for (var x in outer) {
                    for (var y in inner) {
                        continue outerLabel;
                    }

                    total = total + 100;
                }

                return total;
            }

            probe({ a: 1, b: 2 }, { c: 3 });
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=probe argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DirectBranchReturnFunction_UsesUnifiedBytecodeProductionFastPathForTrueAndFalseOutcomes()
    {
        await using var engine = CreateEngine();
        var trueResult = await engine.Evaluate("""
            function pick(flag) {
                var branch = flag;
                if (branch) {
                    return 1;
                }

                return 2;
            }

            pick(true);
            """);

        var falseResult = await engine.Evaluate("""
            pick(false);
            """);

        Assert.Equal(1d, trueResult);
        Assert.Equal(2d, falseResult);
        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=pick",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BinaryReturnFunction_KeepsExistingSpecializedFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function add(a, b) {
                return a + b;
            }

            add(20, 22);
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(42d, result);
        Assert.DoesNotContain(logRecords,
            static record => record.Message.Contains(UnifiedBytecodeProductionFastPathLog, StringComparison.Ordinal));
        Assert.Contains(logRecords,
            static record => record.Message.Contains(SimpleIrParameterNumberBinaryFastPathLog, StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BinaryChainReturnFunction_KeepsExistingSpecializedFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function addChain(a, b, c) {
                return a + b + c;
            }

            addChain(10, 20, 12);
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(42d, result);
        Assert.DoesNotContain(logRecords,
            static record => record.Message.Contains(UnifiedBytecodeProductionFastPathLog, StringComparison.Ordinal));
        Assert.Contains(logRecords,
            static record => record.Message.Contains(SimpleIrParameterNumberBinaryChainFastPathLog, StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BinaryComparisonFunction_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function isLess(a, b) {
                return a < b;
            }

            isLess(20, 22);
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(true, result);
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=isLess argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DirectIdentifierCall_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function helper(value) {
                return value + 1;
            }

            function invoke(helper, value) {
                return helper(value);
            }

            invoke(helper, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ZeroArgumentIdentifierCall_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function helper() {
                return 42;
            }

            function invoke(helper) {
                return helper();
            }

            invoke(helper);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TwoArgumentIdentifierCall_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function helper(left, right) {
                return left + right;
            }

            function invoke(helper, left, right) {
                return helper(left, right);
            }

            invoke(helper, 20, 22);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DirectEvalIdentifierCall_UsesCallerEnvironmentOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invokeEval() {
                var local = 42;
                return eval("local");
            }

            invokeEval();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invokeEval argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DirectEvalIdentifierCall_SyncsMutatedCallerSlotsOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invokeEval(source) {
                var local = 1;
                eval(source);
                return local;
            }

            invokeEval("local = 42;");
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invokeEval argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DirectEvalNewTarget_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var newTarget = null;
            function getNewTarget() {
                newTarget = eval("new.target;");
            }

            getNewTarget();
            var callResult = newTarget === undefined;

            new getNewTarget();
            [callResult, newTarget === getNewTarget].join(",");
            """);

        Assert.Equal("true,true", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=getNewTarget argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DiscardedIdentifierCall_UsesUnifiedBytecodeProductionFastPathAndKeepsSideEffects()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            function observe(value) {
                hits = hits + value;
            }

            function invokeDiscarded(callback, value) {
                callback(value);
                return value;
            }

            invokeDiscarded(observe, 42) + hits;
            """);

        Assert.Equal(84d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invokeDiscarded argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DirectEvalIdentifierCall_UsesOrdinaryCallWhenEvalIsShadowed()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invokeEval(eval) {
                return eval("local");
            }

            invokeEval(function(_) { return 99; });
            """);

        Assert.Equal(99d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invokeEval argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ParameterPassedDebugAwareIdentifierCall_PreservesCallerEnvironment()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(fn) {
                return fn();
            }

            invoke(__debug);
            """);

        Assert.Equal(Symbol.Undefined, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=1",
                StringComparison.Ordinal));

        var debugMessage = await engine.DebugMessages().ReadAsync();
        Assert.Contains("fn", debugMessage.Variables.Keys);
        Assert.Contains(debugMessage.EnvironmentChain,
            static environment => environment.HasSlots && environment.SlotCount > 0);
    }

    [Fact(Timeout = 5000)]
    public async Task BlockScopedDebugAwareIdentifierCall_PreservesActiveLexicalEnvironment()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(fn) {
                var result = 0;
                {
                    let x = 1;
                    result = x;
                    fn();
                }

                return result;
            }

            invoke(__debug);
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=1",
                StringComparison.Ordinal));

        var debugMessage = await engine.DebugMessages().ReadAsync();
        Assert.Contains("fn", debugMessage.Variables.Keys);
        Assert.Contains("x", debugMessage.Variables.Keys);
        Assert.Equal(1d, debugMessage.Variables["x"]);
        Assert.Contains(debugMessage.EnvironmentChain,
            static environment => string.Equals(
                environment.Description,
                "unified-bytecode-scope",
                StringComparison.Ordinal) &&
                environment.HasSlots);
    }

    [Fact(Timeout = 5000)]
    public async Task NonCallableIdentifierCall_PropagatesTypeErrorThroughUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(fn) {
                return fn();
            }

            try {
                invoke(1);
                "missing";
            } catch (error) {
                error instanceof TypeError;
            }
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedMemberCall_UsesUnifiedBytecodeProductionFastPathAndPreservesThis()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {
                read(value) {
                    return this === box ? value + 1 : -1;
                }
            };

            function invoke(box, value) {
                return box.read(value);
            }

            invoke(box, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedMemberCall_UsesUnifiedBytecodeProductionFastPathAndPreservesThis()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {
                offset: 1,
                read(value) {
                    return value + this.offset;
                }
            };

            function invoke(box, key, value) {
                return box[key](value);
            }

            invoke(box, { toString() { return "read"; } }, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedMemberCallWithExpressionKey_UsesUnifiedBytecodeProductionFastPathAndPreservesThis()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {
                offset: 1,
                read(value) {
                    return value + this.offset;
                }
            };

            function invoke(box, left, right, value) {
                return box[left + right](value);
            }

            invoke(box, "re", "ad", 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=4",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DeepComputedMemberCall_UsesUnifiedBytecodeProductionFastPathAndPreservesThis()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var root = {
                child: {
                    branch: {
                        leaf: {
                            offset: 1,
                            read(value) {
                                return this === root.child.branch.leaf ? value + this.offset : -1;
                            }
                        }
                    }
                }
            };

            function invoke(root, key, value) {
                return root.child.branch.leaf[key](value);
            }

            invoke(root, "read", 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedMemberCall_NullishReceiverThrowsBeforeKeyCoercion()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(box, key) {
                return box[key]();
            }

            var key = {
                count: 0,
                toString() {
                    this.count++;
                    return "read";
                }
            };

            try {
                invoke(null, key);
                "missing";
            } catch (error) {
                [
                    error instanceof TypeError,
                    key.count
                ].join("|");
            }
            """);

        Assert.Equal("true|0", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedNamedMemberCall_BindsThisToFinalReceiver()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var root = {
                offset: 100,
                child: {
                    offset: 1,
                    read(value) {
                        return value + this.offset;
                    }
                }
            };

            function invoke(root, value) {
                return root.child.read(value);
            }

            invoke(root, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DeeperNamedMemberCall_BindsThisToDeepestReceiver()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var root = {
                offset: 1000,
                child: {
                    offset: 100,
                    branch: {
                        offset: 10,
                        leaf: {
                            offset: 1,
                            read(value) {
                                return this === root.child.branch.leaf ? value + this.offset : -1;
                            }
                        }
                    }
                }
            };

            function invoke(root, value) {
                return root.child.branch.leaf.read(value);
            }

            invoke(root, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedMemberCall_PreservesKeyConversionSideEffectsAndThisBinding()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var log = "";
            var key = {
                toString() {
                    log = log + "k";
                    return "read";
                }
            };
            var box = {
                offset: 1,
                read(value) {
                    log = log + (this === box ? "t" : "x");
                    return value + this.offset;
                }
            };

            function invoke(box, key, value) {
                return box[key](value);
            }

            invoke(box, key, 41) + ":" + log;
            """);

        Assert.Equal("42:kt", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedMemberCall_NullishReceiverPreservesFallbackTypeErrorShape()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var converted = 0;
            var key = {
                toString() {
                    converted = 1;
                    return "read";
                }
            };

            function invoke(box, key) {
                return box[key]();
            }

            try {
                invoke(null, key);
                "missing";
            } catch (error) {
                (error instanceof TypeError) + ":" + converted;
            }
            """);

        Assert.Equal("true:0", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedMemberCall_NonCallableCalleePreservesFallbackTypeErrorShape()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = { read: 1 };

            function invoke(box, key) {
                return box[key]();
            }

            try {
                invoke(box, "read");
                "missing";
            } catch (error) {
                error instanceof TypeError;
            }
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ReceiverOptionalNamedMemberCall_ShortCircuitsToUndefinedWhenReceiverNullish()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(box) {
                return box?.read();
            }

            invoke(null) + "," + invoke(undefined);
            """);

        Assert.Equal("undefined,undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ReceiverOptionalNamedMemberCall_InvokesMethodAndPreservesThisWhenReceiverNonNull()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {
                read(value) {
                    return this === box ? value + 1 : -1;
                }
            };

            function invoke(box, value) {
                return box?.read(value);
            }

            invoke(box, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CalleeOptionalNamedMemberCall_ShortCircuitsToUndefinedWhenMethodNullish()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = { read: null };

            function invoke(box) {
                return box.read?.();
            }

            invoke(box) + "," + invoke({ read: undefined });
            """);

        Assert.Equal("undefined,undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CalleeOptionalNamedMemberCall_InvokesMethodAndPreservesThisWhenCalleeNonNull()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {
                offset: 1,
                read(value) {
                    return this === box ? value + this.offset : -1;
                }
            };

            function invoke(box, value) {
                return box.read?.(value);
            }

            invoke(box, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CalleeOptionalComputedMemberCall_ShortCircuitsToUndefinedWhenMethodNullish()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = { read: null };

            function invoke(box, key) {
                return box[key]?.();
            }

            invoke(box, "read") + "," + invoke({ read: undefined }, "read");
            """);

        Assert.Equal("undefined,undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CalleeOptionalComputedMemberCall_InvokesMethodAndPreservesThisWhenCalleeNonNull()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {
                offset: 1,
                read(value) {
                    return this === box ? value + this.offset : -1;
                }
            };

            function invoke(box, key, value) {
                return box[key]?.(value);
            }

            invoke(box, "read", 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedPropertyRead_ReturnsUndefinedWhenBaseIsNull()
    {
        // gh2771: a?.b short-circuits to undefined when base is null/undefined.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readOptional(box) {
                return box?.value;
            }

            readOptional(null);
            """);

        Assert.Equal("undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptional",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedPropertyRead_ReturnsPropertyValueWhenBaseIsNonNull()
    {
        // gh2771: a?.b returns the property value when base is not null/undefined.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readOptional(box) {
                return box?.value;
            }

            readOptional({ value: 42 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptional",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalComputedPropertyRead_ReturnsUndefinedWhenBaseIsNull()
    {
        // gh2771: a?.[k] short-circuits to undefined when base is null/undefined.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readOptionalComputed(box, key) {
                return box?.[key];
            }

            readOptionalComputed(null, "value");
            """);

        Assert.Equal("undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptionalComputed",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalComputedPropertyRead_ReturnsPropertyValueWhenBaseIsNonNull()
    {
        // gh2771: a?.[k] returns the property value when base is not null/undefined.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readOptionalComputed(box, key) {
                return box?.[key];
            }

            readOptionalComputed({ value: 42 }, "value");
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptionalComputed",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalComputedPropertyReadAfterNamedPrefix_SkipsKeyOnNullish()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var keyHits = 0;
            var key = {
                toString() {
                    keyHits++;
                    return "item";
                }
            };

            function readOptionalComputed(box, key) {
                return box.child?.[key];
            }

            var whenNull = readOptionalComputed({ child: null }, key);
            var whenPresent = readOptionalComputed({ child: { item: 42 } }, key);
            "" + whenNull + ":" + whenPresent + ":" + keyHits;
            """);

        Assert.Equal("undefined:42:1", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptionalComputed",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedPropertyRead_ReturnsUndefinedWhenBaseIsUndefined()
    {
        // gh2771: a?.b short-circuits to undefined when base is undefined (not only null).
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readOptionalUndef(box) {
                return box?.value;
            }

            readOptionalUndef(undefined);
            """);

        Assert.Equal("undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptionalUndef",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedPropertyReadChain_ReturnsUndefinedWhenBaseIsNull()
    {
        // AC-2: a?.b.c short-circuits to undefined when a is null/undefined.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readOptChain(box) {
                return box?.value.length;
            }

            readOptChain(null);
            """);

        Assert.Equal("undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalComputedPropertyRead_ReturnsUndefinedWhenBaseIsUndefined()
    {
        // gh2771: a?.[k] short-circuits to undefined when base is undefined (not only null).
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readOptionalComputedUndef(box, key) {
                return box?.[key];
            }

            readOptionalComputedUndef(undefined, "value");
            """);

        Assert.Equal("undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptionalComputedUndef",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedPropertyReadChain_ReturnsPropertyValueWhenBaseIsNonNull()
    {
        // AC-2: a?.b.c returns the correct property value when a is non-null.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readOptChain(box) {
                return box?.value.length;
            }

            readOptChain({ value: "hello" });
            """);

        Assert.Equal(5d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOptChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedPropertyRead_EvaluatesBaseExactlyOnce()
    {
        // gh2771: GetNamedPropertyOptional must not re-evaluate the base expression.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var callCount = 0;
            function getBox() {
                callCount++;
                return { value: 42 };
            }
            function countedOptNamed() {
                return getBox()?.value;
            }
            countedOptNamed();
            callCount;
            """);

        Assert.Equal(1d, result);
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalComputedPropertyRead_EvaluatesBaseExactlyOnce()
    {
        // gh2771: JumpIfNullishReplaceUndefined must not re-evaluate the base expression.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var callCount = 0;
            function getBox() {
                callCount++;
                return { value: 42 };
            }
            function countedOptComputed() {
                return getBox()?.["value"];
            }
            countedOptComputed();
            callCount;
            """);

        Assert.Equal(1d, result);
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedPropertyReadChain_BaseEvaluatedOnceWhenShortCircuiting()
    {
        // AC-2 gate: the base is evaluated exactly once even when short-circuiting.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var count = 0;
            function makeNull() { count++; return null; }
            function readOptChain(box) {
                return box?.value.length;
            }

            readOptChain(makeNull());
            count;
            """);

        Assert.Equal(1d, result);
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalThenRegularNamedChain_ReturnsUndefinedWhenBaseIsNull()
    {
        // AC-1: a?.b.c short-circuits the whole chain to undefined when the base is null.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readChain(a) {
                return a?.b.c;
            }

            readChain(null);
            """);

        Assert.Equal("undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalThenRegularNamedChain_ReturnsUndefinedWhenBaseIsUndefined()
    {
        // AC-1: a?.b.c short-circuits to undefined when the base is undefined (not only null).
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readChain(a) {
                return a?.b.c;
            }

            readChain(undefined);
            """);

        Assert.Equal("undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalThenRegularNamedChain_ReturnsDeepValueWhenBaseIsNonNull()
    {
        // AC-2: a?.b.c reads through the full chain when the base is non-null.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readChain(a) {
                return a?.b.c;
            }

            readChain({ b: { c: 42 } });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalThenRegularNamedChain_ThrowsTypeErrorWhenIntermediateIsRealUndefined()
    {
        // AC-3: a?.b.c with a = { b: undefined } must throw TypeError — the short-circuit only
        // propagates when the base is null/undefined, not when a real-undefined intermediate
        // value is read by a following non-optional hop.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readChain(a) {
                return a?.b.c;
            }

            var captured = false;
            try {
                readChain({ b: undefined });
            } catch (error) {
                captured = error instanceof TypeError;
            }

            captured;
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ChainedOptionalNamedChain_ShortCircuitsAtEachOptionalHop()
    {
        // a?.b?.c: each optional hop short-circuits to undefined when its own target is nullish,
        // while the full read succeeds when every hop is present.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readChain(a) {
                return a?.b?.c;
            }

            var whenInnerNull = readChain({ b: null });
            var whenPresent = readChain({ b: { c: 7 } });
            "" + whenInnerNull + ":" + whenPresent;
            """);

        Assert.Equal("undefined:7", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedChainAfterNamedPrefix_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readChain(a) {
                return a.box?.value;
            }

            var whenNull = readChain({ box: null });
            var whenPresent = readChain({ box: { value: 42 } });
            "" + whenNull + ":" + whenPresent;
            """);

        Assert.Equal("undefined:42", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedThenComputedRichKey_ReadsValueThroughProductionFastPath()
    {
        // a?.b[left + right]: rich key continuations use the production fast path.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readChain(a, left, right) {
                return a?.items[left + right];
            }

            var whenPresent = readChain({ items: { id: 42 } }, "i", "d");
            whenPresent;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedThenComputedAfterNamedPrefix_SkipsKeyOnNullish()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var keyHits = 0;
            var key = {
                toString() {
                    keyHits++;
                    return "item";
                }
            };

            function readChain(a, key) {
                return a.box?.items[key];
            }

            var whenNull = readChain({ box: null }, key);
            var whenPresent = readChain({ box: { items: { item: 42 } } }, key);
            "" + whenNull + ":" + whenPresent + ":" + keyHits;
            """);

        Assert.Equal("undefined:42:1", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedThenComputedRichKeyWithTrailingNamedRead_ShortCircuitsBeforeKey()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var keyHits = 0;
            var left = {
                valueOf() {
                    keyHits++;
                    return "i";
                }
            };
            var right = {
                valueOf() {
                    keyHits++;
                    return "d";
                }
            };
            function readChain(a, left, right) {
                return a?.items[left + right].value;
            }

            var whenNull = readChain(null, left, right);
            var nullHits = keyHits;
            var whenPresent = readChain({ items: { id: { value: 42 } } }, left, right);
            "" + whenNull + ":" + nullHits + ":" + whenPresent + ":" + keyHits;
            """);

        Assert.Equal("undefined:0:42:2", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readChain",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalThenRegularNamedChain_EvaluatesBaseExactlyOnce()
    {
        // Gate 1: the base expression must be evaluated exactly once even for a multi-hop chain.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var callCount = 0;
            function getBox() {
                callCount++;
                return { b: { c: 42 } };
            }
            function countedChain() {
                return getBox()?.b.c;
            }
            countedChain();
            callCount;
            """);

        Assert.Equal(1d, result);
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalChainComputedPlainCall_SkipsComputedKeyWhenBaseIsNullish()
    {
        // gh2828 AC-2: a?.b[k]() short-circuits before evaluating the computed key when base is nullish.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var keyEvalCount = 0;
            function getKey() {
                keyEvalCount++;
                return "run";
            }
            function invoke(a) {
                return a?.box[getKey()]();
            }

            var value = invoke(undefined);
            "" + value + ":" + keyEvalCount;
            """);

        Assert.Equal("undefined:0", result?.ToString());
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalChainComputedPlainCall_BindsReceiverToNamedHopObject()
    {
        // gh2828 AC-3: a?.b[k]() preserves receiver binding to a.b for the computed call target.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(a, key) {
                return a?.box[key]();
            }

            var captured = false;
            var holder = {
                box: {
                    run: function () {
                        captured = this === holder.box;
                        return 7;
                    }
                }
            };

            var value = invoke(holder, "run");
            "" + value + ":" + captured;
            """);

        Assert.Equal("7:true", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalChainComputedPlainSpreadCall_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(a, key, args) {
                return a?.box[key](...args);
            }

            var holder = {
                box: {
                    sum(a, b) {
                        return this === holder.box ? a + b : -1;
                    }
                }
            };

            var present = invoke(holder, "sum", [20, 22]);
            var missing = invoke(null, "sum", [1, 2]);
            present + ":" + missing;
            """);

        Assert.Equal("42:undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalChainNamedPrefixPlainCall_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(a, value) {
                return a.x?.box.read(value);
            }

            var holder = {
                x: {
                    box: {
                        read(value) {
                            return this === holder.x.box ? value + 1 : -1;
                        }
                    }
                }
            };

            var present = invoke(holder, 41);
            var missing = invoke({ x: null }, 1);
            present + ":" + missing;
            """);

        Assert.Equal("42:undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalChainNamedPrefixPlainCall_ShortCircuitsBeforePostOptionalRead()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var reads = 0;
            function invoke(a) {
                return a.x?.box.read();
            }

            var holder = {
                x: {
                    get box() {
                        reads++;
                        return { read() { return 7; } };
                    }
                }
            };

            var missing = invoke({ x: null });
            var afterMissing = reads;
            var present = invoke(holder);
            "" + missing + ":" + afterMissing + ":" + present + ":" + reads;
            """);

        Assert.Equal("undefined:0:7:1", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LooseEqualityBranchFunction_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var truthyResult = await engine.Evaluate("""
            function chooseByLooseEquality(value) {
                if (value == 0) {
                    return 10;
                }

                return 20;
            }

            chooseByLooseEquality("0");
            """);

        var falseResult = await engine.Evaluate("""
            chooseByLooseEquality(1);
            """);

        Assert.Equal(10d, truthyResult);
        Assert.Equal(20d, falseResult);
        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=chooseByLooseEquality argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ThisPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readThis() {
                return this.value;
            }

            readThis.call({ value: 7 });
            """);

        Assert.Equal(7d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readThis argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NewTargetInOrdinaryCall_UsesUnifiedBytecodeProductionFastPathAndReturnsUndefined()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readNewTarget() {
                return new.target;
            }

            readNewTarget();
            """);

        Assert.Equal(Symbol.Undefined, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readNewTarget argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task StrictEqualityBranchFunction_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function chooseByStrictEquality(value) {
                if (value === 0) {
                    return 10;
                }

                return 20;
            }

            chooseByStrictEquality("0");
            """);

        Assert.Equal(20d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=chooseByStrictEquality argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PrimitiveUnaryTypeofAndTemplateStringOperators_UseUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function primitiveLane(value) {
                var text = `${value}`;
                return typeof value + ":" + (+value) + ":" + (-value) + ":" + (!value) + ":" + (~value) + ":" + (void value) + ":" + text;
            }

            primitiveLane("5");
            """);

        Assert.Equal("string:5:-5:false:-6:undefined:5", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=primitiveLane argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TypeOfNonIdentifier_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function kind(value) {
                return typeof (value + 1);
            }

            kind(41);
            """);

        Assert.Equal("number", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=kind argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TypeOfUnresolvedIdentifier_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function kind() {
                return typeof missing;
            }

            kind();
            """);

        Assert.Equal("undefined", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=kind argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TypeOfIdentifierForLexicalTdz_PropagatesReferenceErrorThroughUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function kind() {
                return typeof x;
                let x = 1;
            }

            try {
                kind();
                "missing";
            } catch (e) {
                e.name + ":" + e.message;
            }
            """);

        Assert.Equal("ReferenceError:Cannot access 'x' before initialization", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=kind argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LoadSlotForLexicalTdz_PropagatesReferenceErrorThroughUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function read() {
                return x;
                let x = 1;
            }

            try {
                read();
                "missing";
            } catch (e) {
                e.name + ":" + e.message;
            }
            """);

        Assert.Equal("ReferenceError:Cannot access 'x' before initialization", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=0",
                StringComparison.Ordinal));
    }

    // ── Slice A (#2678): sync iterator / for-in TDZ head environments ──────────────
    // for (const/let x in/of …) owns a per-iteration lexical head. These prove the
    // loop both routes through the production fast path and produces correct results,
    // including head-environment TDZ enforcement during source evaluation.

    [Fact(Timeout = 5000)]
    public async Task ForInConstHead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function collect(obj) {
                var keys = "";
                for (const key in obj) {
                    keys = keys + key;
                }

                return keys;
            }

            collect({ a: 1, b: 2, c: 3 });
            """);

        Assert.Equal("abc", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=collect argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ForOfConstHead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sum(values) {
                var total = 0;
                for (const value of values) {
                    total = total + value;
                }

                return total;
            }

            sum([10, 20, 12]);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sum argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ForOfLetHead_ReassignsPerIteration_OnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function doubled(values) {
                var total = 0;
                for (let value of values) {
                    value = value * 2;
                    total = total + value;
                }

                return total;
            }

            doubled([1, 2, 3]);
            """);

        Assert.Equal(12d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=doubled argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ForOfConstTdzHead_ThrowsReferenceError_OnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function read() {
                for (const x of [x]) {
                    return x;
                }
            }

            try {
                read();
                "missing";
            } catch (e) {
                e.name + ":" + e.message;
            }
            """);

        Assert.Equal("ReferenceError:Cannot access 'x' before initialization", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ForInConstTdzHead_ThrowsReferenceError_OnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function read() {
                for (const k in k) {
                    return k;
                }
            }

            try {
                read();
                "missing";
            } catch (e) {
                e.name + ":" + e.message;
            }
            """);

        Assert.Equal("ReferenceError:Cannot access 'k' before initialization", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ForOfLetHead_CapturedPerIterationBinding_DoesNotUseProductionFastPath()
    {
        // A closure capturing the per-iteration binding makes per-iteration freshness observable.
        // The production path declines captured activations wholesale, so this must run on the legacy
        // path (no fast-path log) while still producing the correct per-iteration values [1,2,3].
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function captured(values) {
                var fns = [];
                for (let value of values) {
                    fns.push(function () { return value; });
                }

                var sum = 0;
                for (var i = 0; i < fns.length; i = i + 1) {
                    sum = sum + fns[i]();
                }

                return sum;
            }

            captured([1, 2, 3]);
            """);

        Assert.Equal(6d, result);
        Assert.DoesNotContain(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=captured",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BlockLexicalScope_UsesUnifiedBytecodeProductionFastPathAndPreservesShadowing()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function scoped(value) {
                var result = value;
                {
                    let value = 5;
                    const next = value + 1;
                    result = next;
                }

                return result + value;
            }

            scoped(10);
            """);

        Assert.Equal(16d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=scoped argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task IntegratedCompletedLaneProgram_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function integrated(box, n, key, seed) {
                var total = seed;
                var values = [1, , n];
                var record = { first: 1, [key]: n };
                {
                    let local = record[key];
                    const currentRaw = box.value;
                    const current = +currentRaw;
                    total = total + local + current;
                }

                while (n > 0) {
                    total = total + n;
                    n = n - 1;
                }

                box.value = total;
                var count = ++box.count;
                var stored = box.value;
                return stored + count + 1 + 3;
            }

            integrated({ value: 5, count: 0 }, 3, "dynamic", 10);
            """);

        Assert.Equal(29d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=integrated argc=4",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BlockLexicalScope_ReadBeforeDeclarationPreservesTdz()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function scoped() {
                {
                    var result = value;
                    let value = 1;
                }

                return 0;
            }

            try {
                scoped();
                "missing";
            } catch (e) {
                e.name + ":" + e.message;
            }
            """);

        Assert.Equal("ReferenceError:Cannot access 'value' before initialization", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=scoped argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task UnaryCoercionAbruptCompletion_PropagatesThroughUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function plus(value) {
                return +value;
            }

            try {
                plus({
                    valueOf() {
                        throw new Error("boom");
                    }
                });
                "missing";
            } catch (e) {
                e.message;
            }
            """);

        Assert.Equal("boom", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=plus argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DiscardedPropertyRead_UsesUnifiedBytecodeProductionFastPathAndKeepsSideEffects()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var box = {};
            Object.defineProperty(box, "value", {
                get() {
                    hits = hits + 1;
                    return 41;
                }
            });

            function discardRead(box) {
                box.value;
                return 1;
            }

            discardRead(box) + hits;
            """);

        Assert.Equal(2d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=discardRead argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task EmptyReturns_UseUnifiedBytecodeProductionFastPathAndReturnUndefined()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function explicitEmpty() {
                return;
            }

            function implicitEmpty(value) {
                var local = value;
            }

            explicitEmpty() === undefined && implicitEmpty(1) === undefined;
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(true, result);
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=explicitEmpty argc=0",
                StringComparison.Ordinal));
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=implicitEmpty argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ThrowStatement_UsesUnifiedBytecodeProductionFastPathAndIsCatchable()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function fail(value) {
                throw value;
            }

            var caught = 0;
            try {
                fail(42);
            } catch (error) {
                caught = error;
            }

            caught;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=fail argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DiscardedPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndKeepsSideEffects()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function writeDiscarded(box, value) {
                box.value = value;
                return box.value;
            }

            writeDiscarded({ value: 1 }, 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=writeDiscarded argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DiscardedPropertyUpdate_UsesUnifiedBytecodeProductionFastPathAndKeepsSideEffects()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function updateDiscarded(box) {
                box.value++;
                return box.value;
            }

            updateDiscarded({ value: 1 });
            """);

        Assert.Equal(2d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=updateDiscarded argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DirectivePrologue_UsesUnifiedBytecodeProductionFastPathAndKeepsStrictness()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {};
            Object.defineProperty(box, "value", {
                value: 1,
                writable: false
            });

            function strictWriteDiscarded(box, value) {
                "use strict";
                box.value = value;
                return "not reached";
            }

            var strictThrew = false;
            try {
                strictWriteDiscarded(box, 42);
            } catch (error) {
                strictThrew = error instanceof TypeError;
            }

            strictThrew && box.value === 1;
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=strictWriteDiscarded argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BranchBothArms_UseUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function pick(flag) {
                if (flag) {
                    return 1;
                }

                return 2;
            }

            pick(true) * 10 + pick(false);
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(12d, result);
        Assert.Equal(2, logRecords.Count(record =>
            record.Message.Contains("unified-bytecode-production-fast-path func=pick argc=1", StringComparison.Ordinal)));
    }

    [Fact(Timeout = 5000)]
    public async Task BranchJoinedLocalUpdates_UseUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function choose(pick) {
                var value = 1;
                if (pick) {
                    value = 2;
                } else {
                    value = 3;
                }

                return value;
            }

            choose(true) * 10 + choose(false);
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(23d, result);
        Assert.Equal(2, logRecords.Count(record =>
            record.Message.Contains("unified-bytecode-production-fast-path func=choose argc=1", StringComparison.Ordinal)));
    }

    [Theory(Timeout = 5000)]
    [InlineData(0, 0)]
    [InlineData(4, 10)]
    public async Task CanonicalWhileLoop_UsesUnifiedBytecodeProductionFastPath(int input, int expected)
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate($$"""
            function sumTo(n) {
                var total = 0;
                while (n > 0) {
                    total = total + n;
                    n = n - 1;
                }

                return total;
            }

            sumTo({{input}});
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal((double)expected, result);
        Assert.Contains(logRecords,
            record => record.Message.Contains("unified-bytecode-production-fast-path func=sumTo argc=1", StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task StringConcatenationBinary_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function concatWithSuffix(value) {
                return value + "!";
            }

            concatWithSuffix("ok");
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal("ok!", result?.ToString());
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=concatWithSuffix argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyRead_UsesUnifiedBytecodeProductionFastPathAndGetterSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var box = {};
            Object.defineProperty(box, "value", {
                get() {
                    hits = hits + 1;
                    return 41;
                }
            });

            function read(box) {
                return box.value;
            }

            read(box) + hits;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BinaryExpressionNamedPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readBinaryTarget(left, right) {
                return (left + right).length;
            }

            readBinaryTarget("xy", "z");
            """);

        Assert.Equal(3d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readBinaryTarget argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TryCatch_GetterThrow_IsCaughtOnProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function recover(box) {
                try {
                    return box.value;
                } catch (error) {
                    return "caught:" + error;
                }
            }

            recover({
                get value() {
                    throw "boom";
                }
            });
            """);

        Assert.Equal("caught:boom", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=recover argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyRead_UsesUnifiedBytecodeProductionFastPathAndPrimitiveBoxing()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function read(value) {
                return value.length;
            }

            read("abcd");
            """);

        Assert.Equal(4d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyRead_UsesUnifiedBytecodeProductionFastPathAndProxyGetSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var proxy = new Proxy({ value: 40 }, {
                get(target, prop) {
                    hits = hits + 1;
                    return target[prop] + 1;
                }
            });

            function read(box) {
                return box.value;
            }

            read(proxy) + hits;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ArrayLiteralConstruction_UsesUnifiedBytecodeProductionFastPathAndPreservesHoles()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function create(value) {
                return [1, , [value]];
            }

            var array = create(7);
            array.length === 3 && array[0] === 1 && !(1 in array) && array[2][0] === 7;
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=create argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectLiteralConstruction_UsesUnifiedBytecodeProductionFastPathAndPreservesDataSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function create(key, proto) {
                return { __proto__: proto, a: 1, a: 2, [key]: 3 };
            }

            var object = create("b", { inherited: 9 });
            object.a + object.b + object.inherited;
            """);

        Assert.Equal(14d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=create argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectLiteralConstruction_UsesUnifiedBytecodeProductionFastPathAndCoercesComputedKeys()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function create(key) {
                return { [key]: 41 };
            }

            create(key).value + hits;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=create argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleSourceArraySpread_UsesUnifiedBytecodeProductionFastPathAndSpreadsCorrectly()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function spreadArray(source) {
                return [1, ...source];
            }

            spreadArray([41])[1];
            """);

        Assert.Equal(41d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=spreadArray",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ArraySpreadWithDirectNamedCallSource_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function spreadNonSimple(source, take) {
                return [...source.slice(0, take)];
            }

            var result = spreadNonSimple([40, 2, 99], 2);
            result[0] + result[1];
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=spreadNonSimple",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectSpreadWithDirectNamedCallSource_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function spreadObject(source) {
                return { ...source.slice(0) };
            }

            spreadObject([42])[0];
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=spreadObject",
                StringComparison.Ordinal));
    }

    [Theory(Timeout = 5000)]
    [InlineData(
        """
        function methodObject() {
            return { value() { return 42; } };
        }

        methodObject().value();
        """,
        "methodObject",
        42d)]
    public async Task ObjectMethodLiteralConstruction_UsesUnifiedBytecodeProductionFastPath(
        string source,
        string functionName,
        object expected)
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate(source);

        Assert.Equal(expected, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                $"unified-bytecode-production-fast-path func={functionName}",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyRead_UsesUnifiedBytecodeProductionFastPathAndToPropertyKeySemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var box = { value: 40 };
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function read(box, key) {
                return box[key];
            }

            read(box, key) + hits;
            """);

        Assert.Equal(41d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyReadWithRichKey_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function read(box, left, right) {
                return box[left + right];
            }

            read({ value: 42 }, "va", "lue");
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyReadWithRichKey_EvaluatesKeyBeforeNullishThrow()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var keyHits = 0;

            function getKey(left, right) {
                keyHits++;
                return left + right;
            }

            function read(box, left, right) {
                return box[getKey(left, right)];
            }

            var captured = false;
            try {
                read(null, "va", "lue");
            } catch (error) {
                captured = error instanceof TypeError;
            }

            "" + keyHits + ":" + captured;
            """);

        Assert.Equal("1:true", result?.ToString());
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedThenNamedPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function read(box, key) {
                return box[key].value;
            }

            read({ item: { value: 42 } }, "item");
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedThenComputedPropertyRead_EvaluatesComputedKeyOnce_OnUnifiedBytecodeFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var keyHits = 0;
            var key = {
                toString() {
                    keyHits++;
                    return "item";
                }
            };

            function read(box, key) {
                return box?.items[key];
            }

            var value = read({ items: { item: 42 } }, key);
            "" + value + ":" + keyHits;
            """);

        Assert.Equal("42:1", result?.ToString());
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyRead_PropagatesGetterAbruptCompletionThroughUnifiedBytecode()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {};
            Object.defineProperty(box, "value", {
                get() {
                    throw new Error("boom");
                }
            });

            function read(box) {
                return box.value;
            }

            try {
                read(box);
                "missing";
            } catch (e) {
                e.message;
            }
            """);

        Assert.Equal("boom", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TwoHopNamedPropertyRead_UsesUnifiedBytecodeProductionFastPathAndGetterSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var box = {};
            Object.defineProperty(box, "child", {
                get() {
                    hits = hits + 1;
                    return {
                        get value() {
                            hits = hits + 1;
                            return 40;
                        }
                    };
                }
            });

            function read(box) {
                return box.child.value;
            }

            read(box) + hits;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DeeperNamedPropertyRead_UsesUnifiedBytecodeProductionFastPathAndGetterSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var box = {};
            Object.defineProperty(box, "child", {
                get() {
                    hits = hits + 1;
                    return {
                        get branch() {
                            hits = hits + 1;
                            return {
                                get leaf() {
                                    hits = hits + 1;
                                    return {
                                        get value() {
                                            hits = hits + 1;
                                            return 38;
                                        }
                                    };
                                }
                            };
                        }
                    };
                }
            });

            function read(box) {
                return box.child.branch.leaf.value;
            }

            read(box) + hits;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyInNamedChain_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function read(box, key) {
                return box.child[key];
            }

            read({ child: { value: 42 } }, "value");
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=read argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyReadInsideBranch_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readWhen(flag, box) {
                if (flag) {
                    return box.value;
                }

                return 0;
            }

            readWhen(true, { value: 42 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readWhen argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyReadWithCanonicalLoopShape_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readAfterLoop(box, count) {
                while (count > 0) {
                    count = count - 1;
                }

                return box.value;
            }

            readAfterLoop({ value: 42 }, 2);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readAfterLoop argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndSetterSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var box = {};
            Object.defineProperty(box, "value", {
                set(value) {
                    hits = hits + value;
                }
            });

            function write(box, value) {
                return box.value = value;
            }

            write(box, 42) + hits;
            """);

        Assert.Equal(84d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndKeySemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var box = {};
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function write(box, key, value) {
                return box[key] = value;
            }

            write(box, key, 41) + box.value + hits;
            """);

        Assert.Equal(83d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndProxyReceiverIdentity()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var receiverMatches = false;
            var observed = 0;
            var proxy = new Proxy({}, {
                set(target, key, value, receiver) {
                    receiverMatches = receiver === proxy;
                    observed = value;
                    return true;
                }
            });

            function write(box, value) {
                return box.value = value;
            }

            (write(proxy, 42) === 42) && receiverMatches && (observed === 42);
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndStrictSloppyFailureSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {};
            Object.defineProperty(box, "value", {
                value: 1,
                writable: false
            });

            function sloppyWrite(box, value) {
                return box.value = value;
            }

            function strictWrite(box, value) {
                "use strict";
                return box.value = value;
            }

            var sloppyResult = sloppyWrite(box, 42);
            var sloppyStored = box.value;
            var strictThrew = false;
            try {
                strictWrite(box, 43);
            } catch (error) {
                strictThrew = error instanceof TypeError;
            }

            (sloppyResult === 42) && (sloppyStored === 1) && strictThrew && (box.value === 1);
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(true, result);
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sloppyWrite argc=2",
                StringComparison.Ordinal));
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=strictWrite argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndEvaluationOrder()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            var box = new Proxy({}, {
                set(target, key, value, receiver) {
                    events.push("set:" + String(key) + ":" + value);
                    target[key] = value;
                    return true;
                }
            });
            var key = {
                toString() {
                    events.push("key");
                    return "value";
                }
            };

            function rhs() {
                events.push("rhs");
                return 9;
            }

            function write(box, key, value) {
                return box[key] = value;
            }

            String(write(box, key, rhs())) + ":" + events.join(",");
            """);

        Assert.Equal("9:rhs,key,set:value:9", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedCompoundPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndGetterSetterSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            var box = {};
            Object.defineProperty(box, "value", {
                get() {
                    events.push("get");
                    return 37;
                },
                set(value) {
                    events.push("set:" + value);
                }
            });

            function write(box, value) {
                return box.value += value;
            }

            String(write(box, 5)) + ":" + events.join(",");
            """);

        Assert.Equal("42:get,set:42", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedCompoundPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndResolvesKeyOnce()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            var box = {};
            Object.defineProperty(box, "value", {
                get() {
                    events.push("get");
                    return 4;
                },
                set(value) {
                    events.push("set:" + value);
                }
            });
            var key = {
                toString() {
                    events.push("key");
                    return "value";
                }
            };

            function write(box, key, value) {
                return box[key] += value;
            }

            String(write(box, key, 5)) + ":" + events.join(",");
            """);

        Assert.Equal("9:key,get,set:9", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedCompoundPropertyWriteWithExpressionKey_UsesUnifiedBytecodeProductionFastPathAndResolvesKeyOnce()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            var box = {};
            Object.defineProperty(box, "value", {
                get() {
                    events.push("get");
                    return 4;
                },
                set(value) {
                    events.push("set:" + value);
                }
            });
            var key = {
                toString() {
                    events.push("key");
                    return "val";
                }
            };

            function write(box, key, suffix, value) {
                return box[key + suffix] += value;
            }

            String(write(box, key, "ue", 5)) + ":" + events.join(",");
            """);

        Assert.Equal("9:key,get,set:9", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=4",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyUpdateWithExpressionKey_UsesUnifiedBytecodeProductionFastPathAndResolvesKeyOnce()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            var store = 4;
            var box = {};
            Object.defineProperty(box, "value", {
                get() {
                    events.push("get");
                    return store;
                },
                set(value) {
                    events.push("set:" + value);
                    store = value;
                }
            });
            var key = {
                toString() {
                    events.push("key");
                    return "val";
                }
            };

            function update(box, key, suffix) {
                return box[key + suffix]++;
            }

            String(update(box, key, "ue")) + ":" + store + ":" + events.join(",");
            """);

        Assert.Equal("4:5:key,get,set:5", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedLogicalPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndPreservesShortCircuitSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            var box = {};
            Object.defineProperty(box, "value", {
                get() {
                    events.push("get");
                    return 0;
                },
                set(value) {
                    events.push("set:" + value);
                }
            });
            var key = {
                toString() {
                    events.push("key");
                    return "value";
                }
            };

            function write(box, key, value) {
                return box[key] &&= value;
            }

            String(write(box, key, 5)) + ":" + events.join(",");
            """);

        Assert.Equal("0:key,get", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedLogicalPropertyWriteWithExpressionKey_UsesUnifiedBytecodeProductionFastPathAndPreservesShortCircuitSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            function makeBox(initialValue) {
                var store = initialValue;
                var box = {};
                Object.defineProperty(box, "value", {
                    get() {
                        events.push("get");
                        return store;
                    },
                    set(value) {
                        events.push("set:" + value);
                        store = value;
                    }
                });
                return box;
            }
            var key = {
                toString() {
                    events.push("key");
                    return "val";
                }
            };
            function write(box, key, suffix, value) {
                return box[key + suffix] &&= value;
            }

            String(write(makeBox(0), key, "ue", 7)) + ":" +
                String(write(makeBox(1), key, "ue", 7)) + ":" + events.join(",");
            """);

        Assert.Equal("0:7:key,get,key,get,set:7", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=4",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedLogicalPropertyWriteWithBinaryRhs_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            function makeBox(initialValue) {
                var store = initialValue;
                var box = {};
                Object.defineProperty(box, "value", {
                    get() {
                        events.push("get");
                        return store;
                    },
                    set(value) {
                        events.push("set:" + value);
                        store = value;
                    }
                });
                return box;
            }
            var key = {
                toString() {
                    events.push("key");
                    return "value";
                }
            };
            function write(box, key, value) {
                return box[key] &&= (value + 1);
            }

            String(write(makeBox(0), key, 6)) + ":" +
                String(write(makeBox(1), key, 6)) + ":" + events.join(",");
            """);

        Assert.Equal("0:7:key,get,key,get,set:7", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedLogicalPropertyWriteWithThisKey_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {};
            box[this] = 1;

            function write(box, value) {
                return box[this] &&= value;
            }

            String(write(box, 7)) + ":" + box[this];
            """);

        Assert.Equal("7:7", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedLogicalPropertyWriteWithNewTargetKey_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = { undefined: 1 };

            function write(box, value) {
                return box[new.target] &&= value;
            }

            String(write(box, 7)) + ":" + box.undefined;
            """);

        Assert.Equal("7:7", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=2",
                StringComparison.Ordinal));
    }

    [Theory(Timeout = 5000)]
    [InlineData("&&=", "1", "0", "7", "7", "0")]
    [InlineData("||=", "0", "5", "7", "7", "5")]
    [InlineData("??=", "null", "5", "7", "7", "5")]
    public async Task ComputedLogicalPropertyWrite_AssignmentBranchPreservesResultAndSetterSemantics(
        string logicalOperator,
        string assignInitialValue,
        string shortCircuitInitialValue,
        string rhsValue,
        string expectedAssignedResult,
        string expectedShortCircuitResult)
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate($$"""
            var events = [];
            function makeBox(initialValue) {
                var store = initialValue;
                var box = {};
                Object.defineProperty(box, "value", {
                    get() {
                        events.push("get");
                        return store;
                    },
                    set(value) {
                        events.push("set:" + value);
                        store = value;
                    }
                });
                return box;
            }
            var key = {
                toString() {
                    events.push("key");
                    return "value";
                }
            };
            function rhs(value) {
                events.push("rhs");
                return value;
            }
            function write(box, key, value) {
                return box[key] {{logicalOperator}} rhs(value);
            }

            var assignBox = makeBox({{assignInitialValue}});
            var assignResult = write(assignBox, key, {{rhsValue}});
            var assignEvents = events.join(",");
            events = [];

            var shortCircuitBox = makeBox({{shortCircuitInitialValue}});
            var shortCircuitResult = write(shortCircuitBox, key, {{rhsValue}});
            var shortCircuitEvents = events.join(",");

            String(assignResult) + "|" + assignEvents + "|" + String(shortCircuitResult) + "|" + shortCircuitEvents;
            """);

        Assert.Equal(
            expectedAssignedResult + "|key,get,rhs,set:" + expectedAssignedResult + "|" + expectedShortCircuitResult + "|key,get",
            result);
    }

    [Fact(Timeout = 5000)]
    public async Task NestedNamedLogicalPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndShortCircuits()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            function makeBox(initialValue) {
                var child = {};
                Object.defineProperty(child, "value", {
                    get() {
                        events.push("get");
                        return initialValue;
                    },
                    set(value) {
                        events.push("set:" + value);
                        initialValue = value;
                    }
                });
                return {
                    get child() {
                        events.push("child");
                        return child;
                    }
                };
            }

            function write(box, value) {
                return box.child.value &&= value;
            }

            String(write(makeBox(0), 7)) + ":" + String(write(makeBox(1), 7)) + ":" + events.join(",");
            """);

        Assert.Equal("0:7:child,get,child,get,set:7", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyDelete_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function remove(box) {
                return delete box.value;
            }

            var box = { value: 42 };
            remove(box) && !Object.prototype.hasOwnProperty.call(box, "value");
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedPropertyDelete_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function remove(box) {
                return delete box?.value;
            }

            var box = { value: 42 };
            var removed = remove(box);
            var skipped = remove(null);
            removed + "|" +
                skipped + "|" +
                Object.prototype.hasOwnProperty.call(box, "value");
            """);

        Assert.Equal("true|true|false", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyDelete_UsesUnifiedBytecodeProductionFastPathAndKeySemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function remove(box, key) {
                return delete box[key];
            }

            var box = { value: 42 };
            remove(box, key) && hits === 1 && !Object.prototype.hasOwnProperty.call(box, "value");
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedNamedReceiverComputedPropertyDelete_UsesUnifiedBytecodeProductionFastPathAndKeySemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function remove(box, key) {
                return delete box.child[key];
            }

            var child = { value: 42 };
            var box = { child: child };
            remove(box, key) && hits === 1 && !Object.prototype.hasOwnProperty.call(child, "value");
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedNamedReceiverComputedPropertyDeleteRichKey_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function remove(box, left, right) {
                return delete box.child[left + right];
            }

            var child = { value: 42 };
            var box = { child: child };
            remove(box, "val", "ue") && !Object.prototype.hasOwnProperty.call(child, "value");
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedNamedReceiverComputedPropertyDeleteWithOrdinaryDynamicKey_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var externalKey = "value";
            function remove(box) {
                return delete box.child[externalKey];
            }

            var child = { value: 42 };
            var box = { child: child };
            remove(box) && !Object.prototype.hasOwnProperty.call(child, "value");
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedThenComputedPropertyDelete_UsesUnifiedBytecodeProductionFastPathAndPreservesKeyOrder()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function remove(box, key) {
                return delete box?.child[key];
            }

            var child = { value: 42 };
            var box = { child: child };
            var removed = remove(box, key);
            var skipped = remove(null, key);
            removed + "|" +
                skipped + "|" +
                hits + "|" +
                Object.prototype.hasOwnProperty.call(child, "value");
            """);

        Assert.Equal("true|true|1|false", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalNamedThenOptionalComputedPropertyDelete_UsesUnifiedBytecodeProductionFastPathAndSkipsNullishKey()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function remove(box, key) {
                return delete box?.child?.[key];
            }

            var child = { value: 42 };
            var removed = remove({ child: child }, key);
            var skippedBase = remove(null, key);
            var skippedChild = remove({ child: null }, key);
            removed + "|" +
                skippedBase + "|" +
                skippedChild + "|" +
                hits + "|" +
                Object.prototype.hasOwnProperty.call(child, "value");
            """);

        Assert.Equal("true|true|true|1|false", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task OptionalComputedPropertyDelete_UsesUnifiedBytecodeProductionFastPathAndSkipsNullishKey()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function remove(box, key) {
                return delete box.child?.[key];
            }

            var child = { value: 42 };
            var removed = remove({ child: child }, key);
            var skipped = remove({ child: null }, key);
            removed + "|" +
                skipped + "|" +
                hits + "|" +
                Object.prototype.hasOwnProperty.call(child, "value");
            """);

        Assert.Equal("true|true|1|false", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleOptionalComputedPropertyDelete_UsesUnifiedBytecodeProductionFastPathAndSkipsNullishKey()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function remove(box, key) {
                return delete box?.[key];
            }

            var box = { value: 42 };
            var removed = remove(box, key);
            var skipped = remove(null, key);
            removed + "|" +
                skipped + "|" +
                hits + "|" +
                Object.prototype.hasOwnProperty.call(box, "value");
            """);

        Assert.Equal("true|true|1|false", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=remove argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyDelete_UsesUnifiedBytecodeProductionFastPathAndStrictSloppyFailureSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {};
            Object.defineProperty(box, "value", {
                value: 1,
                configurable: false
            });

            function sloppyRemove(box) {
                return delete box.value;
            }

            function strictRemove(box) {
                "use strict";
                return delete box.value;
            }

            var sloppyResult = sloppyRemove(box);
            var strictThrew = false;
            try {
                strictRemove(box);
            } catch (error) {
                strictThrew = error instanceof TypeError;
            }

            sloppyResult === false && strictThrew && Object.prototype.hasOwnProperty.call(box, "value");
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(true, result);
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sloppyRemove argc=1",
                StringComparison.Ordinal));
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=strictRemove argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedNamedReceiverComputedPropertyDelete_UsesUnifiedBytecodeProductionFastPathAndStrictSloppyFailureSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = { child: {} };
            Object.defineProperty(box.child, "value", {
                value: 1,
                configurable: false
            });

            function sloppyRemove(box, key) {
                return delete box.child[key];
            }

            function strictRemove(box, key) {
                "use strict";
                return delete box.child[key];
            }

            var sloppyResult = sloppyRemove(box, "value");
            var strictThrew = false;
            try {
                strictRemove(box, "value");
            } catch (error) {
                strictThrew = error instanceof TypeError;
            }

            sloppyResult === false && strictThrew && Object.prototype.hasOwnProperty.call(box.child, "value");
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(true, result);
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sloppyRemove argc=2",
                StringComparison.Ordinal));
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=strictRemove argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedCompoundPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndStrictSloppyFailureSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {};
            Object.defineProperty(box, "value", {
                value: 1,
                writable: false
            });

            function sloppyWrite(box, value) {
                return box.value += value;
            }

            function strictWrite(box, value) {
                "use strict";
                return box.value += value;
            }

            var sloppyResult = sloppyWrite(box, 41);
            var sloppyStored = box.value;
            var strictThrew = false;
            try {
                strictWrite(box, 42);
            } catch (error) {
                strictThrew = error instanceof TypeError;
            }

            (sloppyResult === 42) && (sloppyStored === 1) && strictThrew && (box.value === 1);
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(true, result);
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sloppyWrite argc=2",
                StringComparison.Ordinal));
        Assert.Contains(logRecords,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=strictWrite argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyUpdate_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function update(box) {
                return ++box.value;
            }

            var box = { value: 41 };
            update(box) + box.value;
            """);

        Assert.Equal(84d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPostfixPropertyUpdate_UsesUnifiedBytecodeProductionFastPathAndReturnsOldValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function update(box) {
                return box.value++;
            }

            var box = { value: 41 };
            update(box) + box.value;
            """);

        Assert.Equal(83d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPrefixPropertyUpdate_UsesUnifiedBytecodeProductionFastPathAndReturnsNewValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function update(box, key) {
                return ++box[key];
            }

            var box = { value: 41 };
            update(box, "value") + box.value;
            """);

        Assert.Equal(84d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyUpdate_UsesUnifiedBytecodeProductionFastPathAndResolvesKeyOnce()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function update(box, key) {
                return box[key]++;
            }

            var box = { value: 40 };
            update(box, key) + box.value + hits;
            """);

        Assert.Equal(82d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPrefixPropertyDecrement_UsesUnifiedBytecodeProductionFastPathAndReturnsNewValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function update(box) {
                return --box.value;
            }

            var box = { value: 41 };
            update(box) + box.value;
            """);

        Assert.Equal(80d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPostfixPropertyDecrement_UsesUnifiedBytecodeProductionFastPathAndReturnsOldValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function update(box) {
                return box.value--;
            }

            var box = { value: 41 };
            update(box) + box.value;
            """);

        Assert.Equal(81d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPrefixPropertyDecrement_UsesUnifiedBytecodeProductionFastPathAndReturnsNewValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function update(box, key) {
                return --box[key];
            }

            var box = { value: 41 };
            update(box, "value") + box.value;
            """);

        Assert.Equal(80d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyDecrement_UsesUnifiedBytecodeProductionFastPathAndResolvesKeyOnce()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;
            var key = {
                toString() {
                    hits = hits + 1;
                    return "value";
                }
            };

            function update(box, key) {
                return box[key]--;
            }

            var box = { value: 41 };
            update(box, key) + box.value + hits;
            """);

        Assert.Equal(82d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=update argc=2",
                StringComparison.Ordinal));
    }

    [Theory(Timeout = 5000)]
    [InlineData(
        """
        function readAt(values) {
            return values[1];
        }

        readAt([10, 32]);
        """,
        "readAt",
        32d)]
    [InlineData(
        """
        function charAt(value) {
            return value[1];
        }

        charAt("xyz");
        """,
        "charAt",
        "y")]
    public async Task IndexedReads_UseUnifiedBytecodeProductionFastPathWhenAdmitted(
        string source,
        string functionName,
        object expected)
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate(source);

        Assert.Equal(expected, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                $"unified-bytecode-production-fast-path func={functionName} argc=1",
                StringComparison.Ordinal));
    }

    [Theory(Timeout = 5000)]
    [MemberData(nameof(UnsupportedControlFlowFunctions))]
    public async Task UnsupportedControlFlowShapes_DeclineUnifiedBytecodeAndFallBack(
        string source,
        string invocation,
        double expected,
        string functionName)
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate($$"""
            {{source}}

            {{invocation}};
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(expected, result);
        Assert.DoesNotContain(logRecords,
            record => record.Message.Contains(
                $"unified-bytecode-production-fast-path func={functionName}",
                StringComparison.Ordinal));
    }

    [Theory(Timeout = 5000)]
    [MemberData(nameof(SupportedLoopControlFunctions))]
    public async Task SupportedLoopControlShapes_UseUnifiedBytecodeProductionFastPath(
        string source,
        string invocation,
        double expected,
        string functionName,
        int argumentCount)
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate($$"""
            {{source}}

            {{invocation}};
            """);

        var logRecords = CurrentLogger!.Collector.Snapshot();
        Assert.Equal(expected, result);
        Assert.Contains(logRecords,
            record => record.Message.Contains(
                $"unified-bytecode-production-fast-path func={functionName} argc={argumentCount}",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task IdentifierCallStoredInLocal_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function invoke(fn, x) {
                var y = fn(x);
                return y;
            }

            function id(x) {
                return x;
            }

            invoke(id, 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=invoke argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyReadWithSpreadObjectKey_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readComputedSpreadKey(box, source) {
                return box[{ ...source }];
            }

            readComputedSpreadKey({ value: 42 }, { toString() { return "value"; } });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readComputedSpreadKey argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ClassMethodWithSimpleSuperPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Base {
                get value() { return 2; }
            }

            class Derived extends Base {
                readViaSuperBoundary() { return super.value; }
            }

            function readSuper() {
                return new Derived().readViaSuperBoundary();
            }

            readSuper();
            """);

        Assert.Equal(2d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous> argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyReadWithOrdinaryDynamicKey_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var externalKey = "value";
            function readDynamic(box) {
                return box[externalKey];
            }

            readDynamic({ value: 2 });
            """);

        Assert.Equal(2d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readDynamic argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task DynamicIdentifierLookup_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            externalValue = 42;
            function readExternal() {
                return externalValue;
            }

            readExternal();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readExternal argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NamedPropertyWriteWithOrdinaryDynamicValue_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var externalValue = 42;
            function dynamicValueWrite(box) {
                return box.value = externalValue;
            }

            dynamicValueWrite({});
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=dynamicValueWrite argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ComputedPropertyWriteWithExpressionKey_UsesUnifiedBytecodeProductionFastPathAndKeySemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            var box = new Proxy({}, {
                set(target, key, value, receiver) {
                    events.push("set:" + String(key) + ":" + value);
                    target[key] = value;
                    return true;
                }
            });
            var key = {
                toString() {
                    events.push("key");
                    return "val";
                }
            };

            function write(box, key, suffix, value) {
                return box[key + suffix] = value;
            }

            String(write(box, key, "ue", 42)) + ":" + box.value + ":" + events.join(",");
            """);

        Assert.Equal("42:42:key,set:value:42", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=4",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NestedNamedCompoundPropertyWrite_UsesUnifiedBytecodeProductionFastPathAndGetterSetterSemantics()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var events = [];
            var child = {};
            Object.defineProperty(child, "value", {
                get() {
                    events.push("get");
                    return 40;
                },
                set(value) {
                    events.push("set:" + value);
                }
            });
            var box = {
                get child() {
                    events.push("child");
                    return child;
                }
            };

            function write(box, value) {
                return box.child.value += value;
            }

            String(write(box, 2)) + ":" + events.join(",");
            """);

        Assert.Equal("42:child,get,set:42", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=write argc=2",
                StringComparison.Ordinal));
    }

    [Fact]
    public async Task AssignmentDestructuringPropertyTarget_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function destructureWrite(box, source) {
                ({ value: box.value } = source);
                return box.value;
            }

            destructureWrite({ value: 0 }, { value: 42 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=destructureWrite argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ParameterNamedArguments_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readShadow(arguments) {
                let value = arguments;
                return value + 1;
            }

            readShadow(41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readShadow argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LexicalArgumentsBinding_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readShadow() {
                let arguments = 41;
                return arguments + 1;
            }

            readShadow();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readShadow argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TypeOfParameterNamedArguments_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readShadow(arguments) {
                return typeof arguments;
            }

            readShadow(41);
            """);

        Assert.Equal("number", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readShadow argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task TypeOfImplicitArgumentsObject_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readArguments() {
                return typeof arguments;
            }

            readArguments(41);
            """);

        Assert.Equal("object", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readArguments argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task UpdateParameterNamedArguments_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function bump(arguments) {
                arguments++;
                return arguments;
            }

            bump(41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=bump argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task UpdateLexicalArgumentsBinding_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function bump() {
                let arguments = 41;
                ++arguments;
                return arguments;
            }

            bump();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=bump argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task UpdateImplicitArgumentsObject_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function bump() {
                arguments++;
                return typeof arguments + ":" + (arguments !== arguments);
            }

            bump(41);
            """);

        Assert.Equal("number:true", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=bump argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallParameterNamedArguments_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function callShadow(arguments, value) {
                return arguments(value);
            }

            callShadow(function (value) { return value + 1; }, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=callShadow argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallImplicitArgumentsObject_UsesUnifiedBytecodeProductionFastPathAndThrowsTypeError()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function callArguments() {
                return arguments();
            }

            var caught = false;
            try {
                callArguments(41);
            } catch (error) {
                caught = error instanceof TypeError;
            }

            caught;
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=callArguments argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task AssignImplicitArgumentsObject_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function assignArguments() {
                arguments;
                arguments = 1;
                return arguments;
            }

            assignArguments(41);
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=assignArguments argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PrivateFieldIn_UsesUnifiedBytecodeProductionFastPathAndChecksBrand()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Holder {
                #value = 1;

                has(receiver) {
                    return #value in receiver;
                }
            }

            var holder = new Holder();
            holder.has(holder) + ":" + holder.has({});
            """);

        Assert.Equal("true:false", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                UnifiedBytecodeProductionFastPathLog,
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PrivateNamedPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Holder {
                #value = 42;

                read(receiver) {
                    return receiver.#value;
                }
            }

            var holder = new Holder();
            holder.read(holder);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous> argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PrivateNamedPropertyWrite_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Holder {
                #value = 1;

                write(receiver, value) {
                    receiver.#value = value;
                    return receiver.#value;
                }
            }

            var holder = new Holder();
            holder.write(holder, 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous> argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PrivateNamedPropertyUpdate_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Holder {
                #value = 1;

                update(receiver, unused) {
                    return receiver.#value++;
                }

                read(receiver) {
                    return receiver.#value;
                }
            }

            var holder = new Holder();
            holder.update(holder, 0) + ":" + holder.read(holder);
            """);

        Assert.Equal("1:2", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous> argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PrivateNamedCompoundPropertyWrite_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Holder {
                #value = 1;

                add(receiver, value) {
                    return receiver.#value += value;
                }

                read(receiver) {
                    return receiver.#value;
                }
            }

            var holder = new Holder();
            holder.add(holder, 41) + ":" + holder.read(holder);
            """);

        Assert.Equal("42:42", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous> argc=2",
                StringComparison.Ordinal));
    }

    [Theory(Timeout = 5000)]
    [InlineData("&&=", "1", "42:42")]
    [InlineData("&&=", "0", "0:0")]
    [InlineData("||=", "0", "42:42")]
    [InlineData("||=", "7", "7:7")]
    [InlineData("??=", "null", "42:42")]
    [InlineData("??=", "7", "7:7")]
    public async Task PrivateNamedLogicalPropertyWrite_UsesUnifiedBytecodeProductionFastPath(
        string logicalOperator,
        string initialValue,
        string expectedResult)
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate($$"""
            class Holder {
                #value = {{initialValue}};

                assign(receiver, value) {
                    return receiver.#value {{logicalOperator}} value;
                }

                read(receiver) {
                    return receiver.#value;
                }
            }

            var holder = new Holder();
            holder.assign(holder, 42) + ":" + holder.read(holder);
            """);

        Assert.Equal(expectedResult, result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous> argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PrivateNamedMethodCall_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Holder {
                #read(value) {
                    return value + 1;
                }

                call(receiver, value) {
                    return receiver.#read(value);
                }
            }

            var holder = new Holder();
            holder.call(holder, 41);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous> argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ImplicitArgumentsObjectRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function usesArguments() {
                return arguments[0];
            }

            usesArguments(42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=usesArguments argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleZeroArgumentArrowFunction_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var arrowLexical = () => 42;
            arrowLexical();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                UnifiedBytecodeProductionFastPathLog,
                StringComparison.Ordinal));
    }

    [Fact]
    public void SourceGate_OrdinarySyncRouteAttemptsProductionUnifiedBytecodeBeforeGenericIr()
    {
        var repositoryRoot = FindRepositoryRootForSourceGate();
        var invokerPath = Path.Combine(
            repositoryRoot.FullName,
            "src",
            "Asynkron.JsEngine",
            "Ast",
            "TypedAstEvaluator.SyncFunctionInvoker.cs");

        var invokerSource = File.ReadAllText(invokerPath);
        var routeStart = invokerSource.IndexOf(
            "private bool TryInvokeIrFast<TArgs>(",
            StringComparison.Ordinal);
        Assert.True(routeStart >= 0, "Could not locate TryInvokeIrFast route method.");
        var routeEnd = invokerSource.IndexOf(
            "private bool TryInvokeSimpleDerivedClassConstructorFastPath<TArgs>(",
            routeStart,
            StringComparison.Ordinal);
        Assert.True(routeEnd > routeStart, "Could not locate end boundary for TryInvokeIrFast.");
        var routeSource = invokerSource.Substring(routeStart, routeEnd - routeStart);

        var binaryFastPathIndex = routeSource.IndexOf(
            "plan.SimpleReturnParameterBinary",
            StringComparison.Ordinal);
        var binaryChainFastPathIndex = routeSource.IndexOf(
            "plan.SimpleReturnParameterBinaryChain",
            StringComparison.Ordinal);
        var unifiedBytecodeIndex = routeSource.IndexOf(
            "CanUseProductionUnifiedBytecodeFastPath(plan, newTarget)",
            StringComparison.Ordinal);
        var syncIrTrampolineIndex = routeSource.IndexOf(
            "SyncIrCallTrampoline.TryInvoke(",
            StringComparison.Ordinal);
        var genericRunnerIndex = routeSource.IndexOf("new ExecutionPlanRunner(", StringComparison.Ordinal);

        Assert.True(
            binaryFastPathIndex >= 0,
            "Simple binary fast path is missing from the ordinary sync route.");
        Assert.True(
            binaryChainFastPathIndex > binaryFastPathIndex,
            "Binary-chain fast path should stay after the simple binary fast path.");
        Assert.True(
            unifiedBytecodeIndex > binaryChainFastPathIndex,
            "Production unified bytecode should stay behind the specialized simple-return fast paths.");
        Assert.True(
            syncIrTrampolineIndex > unifiedBytecodeIndex,
            "Production unified bytecode should be attempted before SyncIrCallTrampoline.");
        Assert.True(
            genericRunnerIndex > syncIrTrampolineIndex,
            "Generic ExecutionPlanRunner fallback should stay after production unified bytecode and SyncIrCallTrampoline.");
    }

    [Fact]
    public void SourceGate_ProductionUnifiedBytecodeAcceptedPath_DoesNotDelegateToAstOrExecutionPlanRunner()
    {
        var repositoryRoot = FindRepositoryRootForSourceGate();
        var invokerPath = Path.Combine(
            repositoryRoot.FullName,
            "src",
            "Asynkron.JsEngine",
            "Ast",
            "TypedAstEvaluator.SyncFunctionInvoker.cs");
        var vmPath = Path.Combine(
            repositoryRoot.FullName,
            "src",
            "Asynkron.JsEngine",
            "Execution",
            "UnifiedBytecode",
            "UnifiedBytecodeVirtualMachine.cs");

        var invokerSource = File.ReadAllText(invokerPath);
        var acceptedPathStart = invokerSource.IndexOf(
            "private bool TryInvokeProductionUnifiedBytecode<TArgs>(",
            StringComparison.Ordinal);
        Assert.True(acceptedPathStart >= 0, "Could not locate TryInvokeProductionUnifiedBytecode fast-path method.");
        var acceptedPathEnd = invokerSource.IndexOf(
            "private bool TryGetProductionUnifiedBytecodeProgram(",
            acceptedPathStart,
            StringComparison.Ordinal);
        Assert.True(acceptedPathEnd > acceptedPathStart, "Could not locate end boundary for TryInvokeProductionUnifiedBytecode.");
        var acceptedPathSource = invokerSource.Substring(acceptedPathStart, acceptedPathEnd - acceptedPathStart);

        Assert.DoesNotContain("ExecutionPlanRunner", acceptedPathSource, StringComparison.Ordinal);
        Assert.DoesNotContain("ExpressionProgram", acceptedPathSource, StringComparison.Ordinal);
        Assert.DoesNotContain("EvaluateExpression(", acceptedPathSource, StringComparison.Ordinal);
        Assert.DoesNotContain("ProfileEvaluateExpression(", acceptedPathSource, StringComparison.Ordinal);
        Assert.DoesNotContain("EvaluateDynamicExpressionProgram(", acceptedPathSource, StringComparison.Ordinal);

        var vmSource = File.ReadAllText(vmPath);
        Assert.DoesNotContain("ExecutionPlanRunner", vmSource, StringComparison.Ordinal);
        Assert.DoesNotContain("ExpressionProgram", vmSource, StringComparison.Ordinal);
        Assert.DoesNotContain("EvaluateExpression(", vmSource, StringComparison.Ordinal);
        Assert.DoesNotContain("ProfileEvaluateExpression(", vmSource, StringComparison.Ordinal);
        Assert.DoesNotContain("EvaluateDynamicExpressionProgram(", vmSource, StringComparison.Ordinal);
    }

    private static DirectoryInfo FindRepositoryRootForSourceGate()
    {
        var current = new DirectoryInfo(AppContext.BaseDirectory);
        while (current is not null)
        {
            if ((Directory.Exists(Path.Combine(current.FullName, ".git")) ||
                 File.Exists(Path.Combine(current.FullName, ".git")) ||
                 File.Exists(Path.Combine(current.FullName, "Asynkron.JsEngine.sln"))) &&
                Directory.Exists(Path.Combine(current.FullName, "src", "Asynkron.JsEngine")))
            {
                return current;
            }

            current = current.Parent;
        }

        throw new DirectoryNotFoundException("Could not locate repository root for unified-bytecode source gate.");
    }

    // This-binding widening proof pack (issue #2633 / ADR 0279)

    [Fact(Timeout = 5000)]
    public async Task ClassInstanceMethod_ThisPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Point {
                getX() {
                    return this.x;
                }
            }

            var p = new Point();
            p.x = 42;
            p.getX();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PlainObjectMethod_ThisPropertyMutation_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var counter = {
                count: 0,
                inc() {
                    this.count = 1;
                }
            };

            counter.inc();
            counter.count;
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ClassInstanceMethod_ThisPropertyCompoundWrite_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Counter {
                constructor() {
                    this.count = 0;
                }

                add(value) {
                    return this.count += value;
                }
            }

            var c = new Counter();
            c.add(40);
            c.add(2);
            c.count;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PlainObjectMethod_ThisPropertyCompoundWrite_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var counter = {
                count: 0,
                add(value) {
                    return this.count += value;
                }
            };

            counter.add(40);
            counter.add(2);
            counter.count;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task StrictFunction_ThisPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            "use strict";

            function readOwn(obj) {
                return obj.value;
            }

            readOwn({ value: 42 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readOwn",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SloppyFunction_PrimitiveThis_IsCoercedBeforeVmEntry()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function getLength() {
                return this.length;
            }

            getLength.call("hello");
            """);

        Assert.Equal(5d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=getLength",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ClassMethodWithSuperPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Base {}
            Base.prototype.value = 21;

            class Child extends Base {
                readSuper(name) {
                    return super.value + super[name];
                }
            }

            new Child().readSuper("value");
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ClassMethodWithSuperPropertyWriteAndUpdate_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Base {}
            Base.prototype.value = 0;

            class Child extends Base {
                mutateSuper(name) {
                    super.value = 1;
                    super[name] = 2;
                    super.value++;
                    ++super[name];
                    return this.value;
                }
            }

            new Child().mutateSuper("value");
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ClassMethodWithNamedSuperCall_UsesUnifiedBytecodeProductionFastPathAndPreservesReceiver()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Base {
                read(offset) { return this.value + offset; }
            }

            class Child extends Base {
                constructor(value) { super(); this.value = value; }
                readViaSuper(offset) {
                    return super.read(offset);
                }
            }

            new Child(40).readViaSuper(2);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ClassMethodWithComputedSuperCall_UsesUnifiedBytecodeProductionFastPathAndPreservesReceiver()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Base {
                read(offset) { return this.value + offset; }
            }

            class Child extends Base {
                constructor(value) { super(); this.value = value; }
                readViaSuper(name, offset) {
                    return super[name](offset);
                }
            }

            new Child(40).readViaSuper("read", 2);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                UnifiedBytecodeProductionFastPathLog,
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task SimpleArrowFunction_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var choose = (x) => x < 42 ? 42 : x;
            choose(1);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                UnifiedBytecodeProductionFastPathLog,
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ArrowFunction_LexicalThis_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function outer() {
                var readThis = () => this.marker;
                return readThis.call({ marker: 0 });
            }

            outer.call({ marker: 42 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                UnifiedBytecodeProductionFastPathLog,
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ArrowFunction_LexicalNewTarget_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function outer() {
                var readNewTarget = () => typeof new.target;
                this.kind = readNewTarget();
            }

            new outer().kind;
            """);

        Assert.Equal("function", result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ArrowFunction_CapturedOuterEnvironmentRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function makeGetter(obj) {
                return () => obj.value;
            }

            var get = makeGetter({ value: 42 });
            get();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task FunctionExpression_CapturedOuterEnvironmentRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function makeGetter(obj) {
                return function get() {
                    return obj.value;
                };
            }

            var get = makeGetter({ value: 42 });
            get();
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=get",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task FunctionExpression_CapturedOuterEnvironmentWrite_DoesNotUseUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function makeSetter(obj) {
                return function set() {
                    obj.value = 43;
                    return obj.value;
                };
            }

            var set = makeSetter({ value: 42 });
            set();
            """);

        Assert.Equal(43d, result);
        Assert.DoesNotContain(CurrentLogger!.Collector.Snapshot(),
            record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=set",
                StringComparison.Ordinal));
    }

    public static TheoryData<string, string, double, string> UnsupportedControlFlowFunctions =>
        new()
        {
            {
                """
                function unsupportedBranchPayload(a, b, pick) {
                    if (pick) {
                        return Math.max(a, b);
                    }

                    return b;
                }
                """,
                "unsupportedBranchPayload(2, 3, true)",
                3d,
                "unsupportedBranchPayload"
            }
        };

    public static TheoryData<string, string, double, string, int> SupportedLoopControlFunctions =>
        new()
        {
            {
                """
                function breakLoop(n) {
                    while (n > 0) {
                        break;
                    }

                    return n;
                }
                """,
                "breakLoop(3)",
                3d,
                "breakLoop",
                1
            },
            {
                // Labeled loops are now admitted (loop-control targets are compiler-owned, ADR 0253):
                // the unused outer label no longer forces a LabelControlFlow decline.
                """
                function labeled(n) {
                    outer: while (n > 0) {
                        n = n - 1;
                    }

                    return n;
                }
                """,
                "labeled(2)",
                0d,
                "labeled",
                1
            },
            {
                // Labeled break out of a single loop routes through the owned Break opcode.
                """
                function labeledBreak(n) {
                    outer: while (n > 0) {
                        break outer;
                    }

                    return n;
                }
                """,
                "labeledBreak(3)",
                3d,
                "labeledBreak",
                1
            },
            {
                // Labeled continue of a single loop routes through the owned Continue opcode.
                """
                function labeledContinue(n) {
                    var total = 0;
                    outer: while (n > 0) {
                        n = n - 1;
                        continue outer;
                        total = total + 1;
                    }

                    return total;
                }
                """,
                "labeledContinue(3)",
                0d,
                "labeledContinue",
                1
            },
            {
                """
                function continueLoop(n) {
                    var total = 0;
                    while (n > 0) {
                        n = n - 1;
                        continue;
                        total = total + 1;
                    }

                    return total;
                }
                """,
                "continueLoop(3)",
                0d,
                "continueLoop",
                1
            },
            {
                """
                function continueFor(n) {
                    var total = 0;
                    for (; n > 0; n = n - 1) {
                        total = total + n;
                        continue;
                        total = 1000;
                    }

                    return total;
                }
                """,
                "continueFor(3)",
                6d,
                "continueFor",
                1
            },
            {
                """
                function countDo(n) {
                    var count = 0;
                    do {
                        count = count + 1;
                        n = n - 1;
                    } while (n > 0);

                    return count;
                }
                """,
                "countDo(0)",
                1d,
                "countDo",
                1
            }
        };

    [Fact(Timeout = 5000)]
    public async Task CallWithThisArgument_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {
                value: 42,
                invoke(val) {
                    return val === this ? 42 : -1;
                }
            };

            box.run = function runMethod() {
                return this.invoke(this);
            };

            box.run();
            """);

        var logs = CurrentLogger!.Collector.Snapshot();
        foreach (var log in logs)
        {
            output.WriteLine(log.Message);
        }

        Assert.Equal(42d, result);
        Assert.Contains(logs,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=runMethod argc=0",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PropertyWriteWithThis_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var box = {
                self: null
            };

            box.setSelf = function setSelfMethod() {
                this.self = this;
                return this.self === this;
            };

            box.setSelf();
            """);

        var logs = CurrentLogger!.Collector.Snapshot();
        foreach (var log in logs)
        {
            output.WriteLine(log.Message);
        }

        Assert.Equal(true, result);
        Assert.Contains(logs,
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=setSelfMethod argc=0",
                StringComparison.Ordinal));
    }

    // Array-literal and object-literal operand widening (gh2705)

    [Fact(Timeout = 5000)]
    public async Task CallWithArrayLiteralArg_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendPair(receiver, a, b) {
                return receiver([a, b]);
            }

            sendPair(function(arr) { return arr[0] + arr[1]; }, 40, 2);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendPair argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithObjectLiteralArg_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendConfig(receiver, x, y) {
                return receiver({ a: x, b: y });
            }

            sendConfig(function(obj) { return obj.a + obj.b; }, 40, 2);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendConfig argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithEmptyArrayArg_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendEmpty(receiver) {
                return receiver([]);
            }

            sendEmpty(function(arr) { return arr.length; });
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendEmpty argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithEmptyObjectArg_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendEmptyObj(receiver) {
                return receiver({});
            }

            sendEmptyObj(function(obj) { return Object.keys(obj).length; });
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendEmptyObj argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithBinaryTemplateLiteralSubstitution_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function logExpr(receiver, a, b) {
                return receiver(`result: ${a + b}`);
            }

            logExpr(function(value) { return value; }, 40, 2);
            """);

        Assert.Equal("result: 42", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=logExpr argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectSpreadGetterThrow_StopsBeforeLaterSpread_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var order = [];
            function spreadObject(source, after) {
                return { ...source, ...after };
            }

            var source = {};
            Object.defineProperty(source, "a", {
                get: function () {
                    order.push("source");
                    throw new RangeError("boom");
                },
                enumerable: true
            });

            var after = {};
            Object.defineProperty(after, "b", {
                get: function () {
                    order.push("after");
                    return 2;
                },
                enumerable: true
            });

            var message = "none";
            try {
                spreadObject(source, after);
            } catch (error) {
                message = error instanceof RangeError ? error.message : "wrong";
            }

            [message, order.join(",")];
            """);

        var steps = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal("boom", steps.Items[0].AsString());
        Assert.Equal("source", steps.Items[1].AsString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=spreadObject argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithMixedScalarAndArrayLiteralArgs_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendMixed(receiver, a, b, c) {
                return receiver(a, [b, c]);
            }

            sendMixed(function(x, arr) { return x + arr[0] + arr[1]; }, 10, 12, 20);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendMixed argc=4",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task PowerOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function power(a, b) {
                return a ** b;
            }

            power(2, 8);
            """);

        Assert.Equal(256d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=power argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NotEqualOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function notEqual(a, b) {
                return a != b;
            }

            notEqual(1, 2);
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=notEqual argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BitwiseAndOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function bitwiseAnd(a, b) {
                return a & b;
            }

            bitwiseAnd(5, 3);
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=bitwiseAnd argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BitwiseOrOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function bitwiseOr(a, b) {
                return a | b;
            }

            bitwiseOr(5, 3);
            """);

        Assert.Equal(7d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=bitwiseOr argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task BitwiseXorOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function bitwiseXor(a, b) {
                return a ^ b;
            }

            bitwiseXor(5, 3);
            """);

        Assert.Equal(6d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=bitwiseXor argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LeftShiftOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function leftShift(a, b) {
                return a << b;
            }

            leftShift(1, 3);
            """);

        Assert.Equal(8d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=leftShift argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task RightShiftOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function rightShift(a, b) {
                return a >> b;
            }

            rightShift(8, 1);
            """);

        Assert.Equal(4d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=rightShift argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task UnsignedRightShiftOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function unsignedRightShift(a, b) {
                return a >>> b;
            }

            unsignedRightShift(-1, 28);
            """);

        Assert.Equal(15d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=unsignedRightShift argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task InOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function hasKey(key, obj) {
                return key in obj;
            }

            hasKey("x", { x: 1 });
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=hasKey argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task InstanceOfOperator_ProducesCorrectResult_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function isInstance(value, ctor) {
                return value instanceof ctor;
            }

            isInstance([], Array);
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=isInstance argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task InOperator_ThrowsTypeError_WhenRhsIsPrimitive_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function testIn(key, target) {
                return key in target;
            }

            var caught = false;
            try {
                testIn("x", 42);
            } catch (e) {
                caught = e instanceof TypeError;
            }
            caught;
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=testIn argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task InstanceOfOperator_ThrowsTypeError_WhenRhsIsPrimitive_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function testInstanceOf(value, target) {
                return value instanceof target;
            }

            var caught = false;
            try {
                testInstanceOf({}, 42);
            } catch (e) {
                caught = e instanceof TypeError;
            }
            caught;
            """);

        Assert.Equal(true, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=testInstanceOf argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectLiteralWithShorthandProperties_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function build(a, b) {
                return { a, b };
            }

            var o = build(40, 2);
            o.a + o.b;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=build argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectLiteralSpread_UsesUnifiedBytecodeProductionFastPathAndCopiesSymbolKeys()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function copy(source) {
                return { ...source };
            }

            var sym = Symbol("answer");
            var source = { a: 1 };
            source[sym] = 41;
            var out = copy(source);
            out[sym] + out.a;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=copy argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectLiteralSpreadNamedPropertyRead_UsesUnifiedBytecodeProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function readLiteral(box) {
                return { ...box }.value;
            }

            readLiteral({ value: 42 });
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=readLiteral argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectLiteralSpread_PreservesOverwriteOrder_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function merge(source) {
                return { a: 1, ...source, b: 2, a: 3 };
            }

            var out = merge({ a: 9, c: 37 });
            out.a + out.b + out.c;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=merge argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectLiteralSpread_NullAndUndefinedSourcesAreNoOps_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function build(left, right) {
                return { ...left, value: 42, ...right };
            }

            build(null, undefined).value;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=build argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task ObjectLiteralSpread_InvokesEnumerableGetters_OnFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function copy(source) {
                return { ...source, other: 1 };
            }

            var hits = 0;
            var source = {};
            Object.defineProperty(source, "value", {
                get: function () {
                    hits = hits + 1;
                    return 41;
                },
                enumerable: true
            });

            var out = copy(source);
            [out.value + out.other, hits];
            """);

        var values = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(42d, values.Items[0].AsDouble());
        Assert.Equal(1d, values.Items[1].AsDouble());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=copy argc=1",
                StringComparison.Ordinal));
    }

    // gh2742: computed-key object literals in call-argument position

    [Fact(Timeout = 5000)]
    public async Task CallWithComputedIdentifierKeyObjectArg_UsesUnifiedBytecodeProductionFastPathAndStoresValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendComputed(receiver, k, v) {
                return receiver({ [k]: v });
            }

            sendComputed(function(obj) { return obj.result; }, "result", 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendComputed argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithComputedStringLiteralKeyObjectArg_UsesUnifiedBytecodeProductionFastPathAndStoresValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendNamed(receiver, v) {
                return receiver({ ["answer"]: v });
            }

            sendNamed(function(obj) { return obj.answer; }, 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendNamed argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithMixedStaticAndComputedKeyObjectArg_UsesUnifiedBytecodeProductionFastPathAndPreservesOrder()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendMixed(receiver, k, x, y) {
                return receiver({ a: x, [k]: y });
            }

            var o = sendMixed(function(obj) { return obj; }, "b", 40, 2);
            o.a + o.b;
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendMixed argc=4",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithBinaryComputedKeyObjectArg_UsesUnifiedBytecodeProductionFastPathAndStoresValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function sendBinaryExprKey(receiver, a, b, v) {
                return receiver({ [a + b]: v });
            }

            sendBinaryExprKey(function(obj) { return obj.answer; }, "ans", "wer", 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendBinaryExprKey argc=4",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task CallWithCallExpressionComputedKeyObjectArg_UsesUnifiedBytecodeProductionFastPathAndStoresValue()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var hits = 0;

            function sendCallExprKey(receiver, fn, v) {
                return receiver({ [fn()]: v });
            }

            sendCallExprKey(
                function(obj) { return obj.answer + ":" + hits; },
                function() { hits++; return "answer"; },
                42);
            """);

        Assert.Equal("42:1", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=sendCallExprKey argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalAnd_ShortCircuitsOnFalsyLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function andOp(a, b) {
                return a && b;
            }

            andOp(0, 42);
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=andOp argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalAnd_EvaluatesRight_WhenLeftIsTruthy_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function andOp(a, b) {
                return a && b;
            }

            andOp(1, 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=andOp argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalAnd_LiteralRhs_ShortCircuitsOnFalsy()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function f(a) {
                return a && 99;
            }

            [f(null), f(1)];
            """);

        var arr1 = Assert.IsType<JsTypes.JsArray>(result);
        Assert.True(arr1.Items[0].IsNull);
        Assert.Equal(99d, arr1.Items[1].AsDouble());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=f argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOr_ShortCircuitsOnTruthyLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function orOp(a, b) {
                return a || b;
            }

            orOp(1, 99);
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=orOp argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOr_EvaluatesRight_WhenLeftIsFalsy_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function orOp(a, b) {
                return a || b;
            }

            orOp(0, 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=orOp argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOr_LiteralFallback_ShortCircuitsOnTruthy()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function f(a) {
                return a || 99;
            }

            [f(0), f(7)];
            """);

        var arr3 = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(99d, arr3.Items[0].AsDouble());
        Assert.Equal(7d, arr3.Items[1].AsDouble());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=f argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishCoalescing_ShortCircuitsOnNonNullishLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function nullishOp(a, b) {
                return a ?? b;
            }

            nullishOp(0, 42);
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=nullishOp argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishCoalescing_EvaluatesRight_WhenLeftIsNull_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function nullishOp(a, b) {
                return a ?? b;
            }

            nullishOp(null, 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=nullishOp argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishCoalescing_EvaluatesRight_WhenLeftIsUndefined_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function nullishOp(a, b) {
                return a ?? b;
            }

            nullishOp(undefined, 42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=nullishOp argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishCoalescing_LiteralFallback_ShortCircuitsOnNonNullish()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function f(a) {
                return a ?? 99;
            }

            [f(null), f(undefined), f(0), f("hello")];
            """);

        var arr5 = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(99d, arr5.Items[0].AsDouble());
        Assert.Equal(99d, arr5.Items[1].AsDouble());
        Assert.Equal(0d, arr5.Items[2].AsDouble());
        Assert.Equal("hello", arr5.Items[3].AsString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=f argc=1",
                StringComparison.Ordinal));
    }

    // Literal-right operand proof pack for &&/||/?? (ADR 0238 batch-5)

    [Fact(Timeout = 5000)]
    public async Task LogicalAnd_LiteralRight_ShortCircuitsOnFalsyLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function andLiteral(a) {
                return a && 42;
            }

            andLiteral(0);
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=andLiteral argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalAnd_LiteralRight_EvaluatesRight_WhenLeftIsTruthy_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function andLiteral(a) {
                return a && 42;
            }

            andLiteral(1);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=andLiteral argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOr_LiteralRight_ShortCircuitsOnTruthyLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function orLiteral(a) {
                return a || 99;
            }

            orLiteral(1);
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=orLiteral argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOr_LiteralRight_EvaluatesRight_WhenLeftIsFalsy_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function orLiteral(a) {
                return a || 99;
            }

            orLiteral(0);
            """);

        Assert.Equal(99d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=orLiteral argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishCoalescing_LiteralRight_ShortCircuitsOnNonNullishLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function nullishLiteral(a) {
                return a ?? 99;
            }

            nullishLiteral(0);
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=nullishLiteral argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishCoalescing_LiteralRight_EvaluatesRight_WhenLeftIsNull_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function nullishLiteral(a) {
                return a ?? 99;
            }

            nullishLiteral(null);
            """);

        Assert.Equal(99d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=nullishLiteral argc=1",
                StringComparison.Ordinal));
    }

    // This-property-left operand proof pack for &&/||/?? (ADR 0238 batch-5)

    [Fact(Timeout = 5000)]
    public async Task LogicalAnd_ThisPropertyLeft_ShortCircuitsOnFalsyLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Guard {
                check(b) {
                    return this.enabled && b;
                }
            }

            var g = new Guard();
            g.enabled = 0;
            g.check(42);
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalAnd_ThisPropertyLeft_EvaluatesRight_WhenLeftIsTruthy_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Guard {
                check(b) {
                    return this.enabled && b;
                }
            }

            var g = new Guard();
            g.enabled = 1;
            g.check(42);
            """);

        Assert.Equal(42d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOr_ThisPropertyLeft_ShortCircuitsOnTruthyLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Fallback {
                resolve(b) {
                    return this.value || b;
                }
            }

            var f = new Fallback();
            f.value = 1;
            f.resolve(99);
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOr_ThisPropertyLeft_EvaluatesRight_WhenLeftIsFalsy_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Fallback {
                resolve(b) {
                    return this.value || b;
                }
            }

            var f = new Fallback();
            f.value = 0;
            f.resolve(99);
            """);

        Assert.Equal(99d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishCoalescing_ThisPropertyLeft_ShortCircuitsOnNonNullishLeft_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Cache {
                resolve(b) {
                    return this.cached ?? b;
                }
            }

            var c = new Cache();
            c.cached = 0;
            c.resolve(99);
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishCoalescing_ThisPropertyLeft_EvaluatesRight_WhenLeftIsNull_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Cache {
                resolve(b) {
                    return this.cached ?? b;
                }
            }

            var c = new Cache();
            c.cached = null;
            c.resolve(99);
            """);

        Assert.Equal(99d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    // Conditional (ternary) expression — ADR 0294

    [Fact(Timeout = 5000)]
    public async Task Ternary_TruthyCondition_ReturnsConsequent_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function pick(cond, a, b) {
                return cond ? a : b;
            }

            pick(1, 10, 20);
            """);

        Assert.Equal(10d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=pick argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task Ternary_FalsyCondition_ReturnsAlternate_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function pick(cond, a, b) {
                return cond ? a : b;
            }

            pick(0, 10, 20);
            """);

        Assert.Equal(20d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=pick argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task Ternary_Nested_ReturnsCorrectBranch_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function classify(x) {
                return x > 0 ? (x > 10 ? 2 : 1) : 0;
            }

            [classify(-1), classify(5), classify(15)];
            """);

        var arr = Assert.IsType<JsTypes.JsArray>(result);
        Assert.Equal(0d, arr.Items[0].AsDouble());
        Assert.Equal(1d, arr.Items[1].AsDouble());
        Assert.Equal(2d, arr.Items[2].AsDouble());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=classify argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task Ternary_ThisPropertyConditionAndArm_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            class Toggle {
                constructor(flag, value) {
                    this.flag = flag;
                    this.value = value;
                }

                select(other) {
                    return this.flag ? this.value : other;
                }
            }

            [new Toggle(true, 42).select(10), new Toggle(false, 42).select(10)].join(",");
            """);

        Assert.Equal("42,10", result?.ToString());
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=<anonymous>",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task Ternary_ConditionIsConsumedNotPeeked_BothBranchesCorrect()
    {
        // AC-2: verifies consume semantics — if the condition were left on the stack
        // (peek), the stack would overflow and results would be wrong across calls.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function pick(cond, a, b) {
                return cond ? a : b;
            }

            pick(1, 10, 20) + pick(0, 10, 20);
            """);

        // 10 (truthy picks a=10) + 20 (falsy picks b=20)
        Assert.Equal(30d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=pick argc=3",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task Ternary_LiteralArms_TruthyCondition_ReturnsConsequentLiteral_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function clamp(a) {
                return a > 0 ? 1 : 0;
            }

            clamp(5);
            """);

        Assert.Equal(1d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=clamp argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task Ternary_Nested_AllCombinationsCorrect_OnProductionFastPath()
    {
        // AC-3: c1 ? (c2 ? a : b) : d — all four combinations of c1/c2.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function nested(c1, c2, a, b, d) {
                return c1 ? c2 ? a : b : d;
            }

            [nested(1,1,10,20,30), nested(1,0,10,20,30), nested(0,1,10,20,30), nested(0,0,10,20,30)].join(',');
            """);

        Assert.Equal("10,20,30,30", result as string);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=nested",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task Ternary_LiteralArms_FalsyCondition_ReturnsAlternateLiteral_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function clamp(a) {
                return a > 0 ? 1 : 0;
            }

            clamp(-3);
            """);

        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=clamp argc=1",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task Ternary_SideEffectOnce_OnlyChosenArmEvaluated()
    {
        // Gate: non-chosen arm must never be evaluated.
        // Note: a ternary with function-call arms is declined from the production fast path;
        // this test verifies behavioral short-circuit correctness independently.
        await using var engine = CreateEngine();

        var countTruthy = await engine.Evaluate("""
            var count = 0;
            function effect(v) { count++; return v; }
            function pick(cond) { return cond ? effect(10) : effect(20); }
            pick(1);
            count;
            """);
        Assert.Equal(1d, countTruthy);
        Assert.DoesNotContain(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=pick",
                StringComparison.Ordinal));

        var countFalsy = await engine.Evaluate("""
            var count2 = 0;
            function effect2(v) { count2++; return v; }
            function pick2(cond) { return cond ? effect2(10) : effect2(20); }
            pick2(0);
            count2;
            """);
        Assert.Equal(1d, countFalsy);
        Assert.DoesNotContain(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=pick2",
                StringComparison.Ordinal));
    }

    // Logical assignment operators on slot identifiers — ADR batch 3

    [Fact(Timeout = 5000)]
    public async Task LogicalAndAssignment_SlotBased_ShortCircuitsOnFalsyLeft_SlotUnchanged_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function andAssign(x, y) {
                x &&= y;
                return x;
            }

            andAssign(0, 99);
            """);

        // x is falsy (0); &&= short-circuits, slot stays 0
        Assert.Equal(0d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=andAssign argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalAndAssignment_SlotBased_ShortCircuitsOnFalsyLeft_RhsNeverEvaluated()
    {
        // Gate 1: &&= short-circuit must not invoke the RHS at all — proven by a side-effecting
        // counter function. If RHS were evaluated, counter would be > 0 after the call.
        // The global function call in the RHS declines the production fast path; correctness
        // of the short-circuit opcode is verified here regardless of which path runs.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            var counter = 0;
            function sideEffect() { counter++; return 99; }
            function andAssign(x) {
                x &&= sideEffect();
                return x;
            }

            andAssign(0);
            counter;
            """);

        // counter must remain 0 — sideEffect() was never called during short-circuit
        Assert.Equal(0d, result);
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalAndAssignment_SlotBased_ProceedsOnTruthyLeft_SlotUpdated_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function andAssign(x, y) {
                x &&= y;
                return x;
            }

            andAssign(5, 99);
            """);

        // x is truthy (5); &&= evaluates y, stores y in x
        Assert.Equal(99d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=andAssign argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOrAssignment_SlotBased_ShortCircuitsOnTruthyLeft_SlotUnchanged_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function orAssign(x, y) {
                x ||= y;
                return x;
            }

            orAssign(5, 99);
            """);

        // x is truthy (5); ||= short-circuits, slot stays 5
        Assert.Equal(5d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=orAssign argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalOrAssignment_SlotBased_ProceedsOnFalsyLeft_SlotUpdated_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function orAssign(x, y) {
                x ||= y;
                return x;
            }

            orAssign(0, 99);
            """);

        // x is falsy (0); ||= evaluates y, stores y in x
        Assert.Equal(99d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=orAssign argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishAssignment_SlotBased_ShortCircuitsOnNonNullishLeft_SlotUnchanged_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function nullishAssign(x, y) {
                x ??= y;
                return x;
            }

            nullishAssign(5, 99);
            """);

        // x is not nullish (5); ??= short-circuits, slot stays 5
        Assert.Equal(5d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=nullishAssign argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task NullishAssignment_SlotBased_ProceedsOnNullLeft_SlotUpdated_UsesProductionFastPath()
    {
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function nullishAssign(x, y) {
                x ??= y;
                return x;
            }

            nullishAssign(null, 99);
            """);

        // x is null (nullish); ??= evaluates y, stores y in x
        Assert.Equal(99d, result);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=nullishAssign argc=2",
                StringComparison.Ordinal));
    }

    [Fact(Timeout = 5000)]
    public async Task LogicalAndAssignment_SlotBased_MultipleCallsDoNotCorruptStack_UsesProductionFastPath()
    {
        // Gate: verifies short-circuit and proceed paths balance the stack correctly across
        // multiple calls — a mismatched Pop would corrupt the stack on repeated invocations.
        await using var engine = CreateEngine();
        var result = await engine.Evaluate("""
            function andAssign(x, y) {
                x &&= y;
                return x;
            }

            [andAssign(0, 99), andAssign(5, 99), andAssign(0, 42), andAssign(7, 42)].join(',');
            """);

        Assert.Equal("0,99,0,42", result as string);
        Assert.Contains(CurrentLogger!.Collector.Snapshot(),
            static record => record.Message.Contains(
                "unified-bytecode-production-fast-path func=andAssign",
                StringComparison.Ordinal));
    }
}