diff --git a/AGENTS.md b/AGENTS.md
index b30f8b4849..aad002dcfe 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -215,6 +215,7 @@ Jint is not only an engine to work on, it is an engine that gets **embedded**. I
 | `Module.Location` — the name a module knows itself by, never null, and the `referencingModuleLocation` its own imports resolve against | `Jint/Runtime/Modules/Module.cs` |
 | `ModuleFactory.LocationOf` — public **static**, the rule deriving that name from a `ResolvedSpecifier`, which a host naming a module itself has to match exactly | `Jint/Runtime/Modules/ModuleFactory.cs` |
 | `IAsyncModuleLoader` + `ModuleLoadCompletion` + `AsyncModuleLoader` + `Module.LoadRequestedModules` + `Engine.Modules.StartImport` / `ImportAsync` + `ModuleImportOperation` | `Jint/Runtime/Modules/`, `Jint/Engine.Modules.cs` |
+| The `*Async` failure channel — which of the two ways out of an `*Async` entry a given failure takes | `Jint/Engine.Async.cs`, `Jint/Engine.Modules.cs`, `Jint/Engine.Pump.cs` |
 
 `Get` and `Set` are overridable too, but they are `public override` of `JsValue` virtuals rather than declared on `ObjectInstance`.
 
@@ -324,6 +325,7 @@ Each of these cost a real integrator or a real bug.
 - **The handler-tree caches engage only on the *second* evaluation of a given script on a given engine.** A host that builds a fresh engine per operation never reaches them, by design. This concerns that cross-run carry-over only — caches which are not engine-scoped still pay back, and CLR member resolution in particular now survives across engines through the shared `TypeResolver` described above, which is the main reason a fresh engine per operation costs less than it used to. `Engine.Advanced.RestoreGlobalSnapshot` deliberately **preserves** these caches (`_scriptStatementLists`, `_functionDefinitions`, `_evaluatedScripts`) while resetting the globals — reaching them from a host that used to need a fresh engine per evaluation is the entire point of that API, and `Jint.Tests/Runtime/GlobalSnapshotInternalsTests.cs` pins it.
 - **A warmed member-read site retains its last receiver.** The prototype-method inline cache stores the receiver, its direct prototype and the resolved descriptor on the handler node (`JintMemberExpression._cachedProtoReceiver`), and only replaces that entry when the same site later caches a *different* receiver — a miss that does not qualify for caching leaves the old one in place. Handler trees are engine-owned and survive between evaluations on a re-running engine, so a pooled engine can hold one host object alive per warmed call site until its next run. Nothing clears these: `Engine.Advanced.ResetCallStack` releases call frames only. A host whose receivers wrap large native state that must not outlive a run should drop the engine rather than pool it. **A warmed *call* site retains its last callee the same way, and one of the two caches is heavier than it looks.** `JintCallExpression._fastCallee` (the built-in fast-call lane) usually holds a realm intrinsic, which the realm roots anyway — but the field is written for whatever `Function` an eligible site dispatched, before and regardless of the shape verdict, so a site with at most two arguments and no spread calling an *interpreted* function pins that too. `_regCallee` (the register-argument lane for interpreted callees) holds a `ScriptFunction` by construction, and a `ScriptFunction` holds the environment it closed over — so a warmed site pins one closure instance, and transitively whatever that closure captured, for the engine's lifetime. It is the same bounded, one-entry-per-site hazard, with the same remedy: drop the engine rather than pool it when the retained graph matters. The bound is per site, not per callee: a polymorphic site overwrites its entry rather than accumulating. The sibling `_regProbedCallee` records what the probe last examined so a rejected callee is not re-probed on every dispatch, and it retains that reference too — for an accepted callee it is the same object as `_regCallee`, so the ceiling stays one live callee per site either way. **Which sites are in the retaining set is decided at build time**, by `_fastArgsEligible` and `_regLaneEligible`: a site with five arguments, or with a spread, can arm neither lane and so records nothing at all. Note also that a site only enters the set once its handler tree outlives the evaluation, i.e. from the second run of the same program on the same engine — a host re-parsing its source every time never warms one, and a `WeakReference` test written against `Execute(string)` therefore proves nothing.
 - **`MaxRecursionDepth` counts one function's occurrences, not stack depth — and a tail call's displaced frame keeps counting.** `JintCallStack._statistics` is a multiset of the live stack keyed by `JintFunctionDefinition` identity (`CallStackElementComparer`), so the limit asks "how many times is *this* function on the stack", never "how deep is the stack". Two consequences. A recursion whose every level is a function created for that level — `eval`, `new Function`, a host re-running a script through a callback — repeats no definition and is invisible to the limit however deep it goes; `Options.Constraints.StackOverflowGuard` is the only thing that covers that shape, and no version of Jint has covered it any other way. And `JintCallStack.ReplaceTop` deliberately does **not** discount the frame a proper tail call replaced: the frame is gone, but the activation is not over while `ScriptFunction.ContinueTailCalls` is still on the native stack, so the occurrence is retained and handed back through `ReleaseTailRetention` in that trampoline's `finally`. Discounting it (which is what the code did through 4.16.0) made the limit blind to a recursion that leaves and re-enters the trampoline by a non-tail route — a getter, `new`, a coercion, a Proxy trap, a host callback — because every re-entry pushed the displaced function again at depth zero while the native stack kept growing, and `LimitRecursion` then ended in a process-killing stack overflow instead of a `RecursionDepthOverflowException`. Pinned from both sides in `Jint.Tests.PublicInterface/HostTailCallTests.cs` and `Jint.Tests/Runtime/TailCallOptimizationTests.cs`; the release half has its own test, because without it a loop over one *completed* tail delegation accumulates against the limit.
+- **An `*Async` entry has two ways out, and which one a failure takes is a contract, not an accident.** Everything the operation itself does — parsing, running the script, an execution constraint tripping, a promise rejecting — is delivered through the returned `Task`. Only a **usage error** is thrown out of the call: a `null` argument, a `Prepared<Script>` that did not come from `PrepareScript`, and the `InvalidOperationException` refusing the call because the engine is already in use. Those three say the operation never started, so there is nothing for a task to describe; everything else says it started and failed, and a host that wrapped its `await` must see it. The rule holds for the whole family — `EvaluateAsync` (both overloads), `ExecuteAsync`, `InvokeAsync`, `Modules.ImportAsync`, `Advanced.WaitForScheduledWorkAsync`, `JsValue.UnwrapIfPromiseAsync` — which is the point of stating it: before it did, the family was split by nothing more principled than which methods happened to be declared `async`. `ExecuteAsync` was, so a budget failure reached its task; `EvaluateAsync` was not, so the identical failure on the identical script erupted from the call. Worse, it erupted *conditionally*: `MemoryLimitConstraint` charges a host callback running on another thread to the same operation, so whether that charge landed before or after the engine thread reached `ScriptEvaluation`'s post-script check decided whether the exception came back as a faulted task or on the caller's stack — a coin flip resolved by thread scheduling, which a host cannot write a `catch` against (issue #3241; it flaked two unrelated PRs in one day). The mechanics that make the rule true: the entry validates arguments, takes the reservation, and *then* hands off to a `private async` body which owns the release in a `finally`. An `async` body captures its synchronous phase into the task, which is exactly the property wanted, so **never move the reservation into that body** (the failure it reports is a usage error) and **never hoist work out of it** (everything else belongs to the task). Nothing about the constraints themselves changed: same exception type, same message, still fatal, still bounding the same work — only the channel is now deterministic. Pinned from the embedder's side in `Jint.Tests.PublicInterface/HostAsyncFailureChannelTests.cs`, in both directions, including a forced-ordering reproduction of the cross-thread charge that needs no repetition to mean something.
 - **Saturated sentinels register nothing.** `MaxStatements(int.MaxValue)`, `LimitMemory(long.MaxValue)` and `TimeoutInterval(TimeSpan.MaxValue)` — and any non-positive value, including `MaxStatements()`'s own parameter default — produce exactly the same engine as never calling the method, and additionally *remove* any previously registered constraint of that kind. A host spelling "effectively unlimited" that way has no limit, not a very large one.
 - **`RestoreGlobalSnapshot` bumps version counters, it never restores them.** `_propertiesVersion`, `GlobalEnvironment._lexicalMutations`, `Engine._envBindingInjectionEpoch` and `EventLoop.Generation` are what every inline cache — and, for the last one, every queued job — validates against, so putting a counter *back* could make an entry built before the capture compare equal again and be revalidated against state it never saw. Anything added to the restore path obeys the same rule. The API's other half is its honesty: it reverts the global *binding table*, and explicitly not intrinsic/prototype mutations, object graphs behind restored bindings, host CLR state (including `Engine.Advanced.HostDefined`, which a pooled engine keeps across a restore and the host swaps per request itself), `Symbol.for`, or the module registry — it is a configuration-reuse primitive, not an isolation boundary, and the non-guarantees are pinned as surviving in `Jint.Tests.PublicInterface/GlobalSnapshotTests.cs`. Since bare identifiers resolve through the global's whole prototype chain, surviving intrinsic pollution is now a surviving **binding** as well as a surviving property: `Object.prototype.leaked = 1` in one cycle makes `leaked` resolvable as a free identifier in the next, where before it was readable only as `globalThis.leaked` and `typeof leaked` answered `"undefined"`. The global's own `[[Prototype]]` is a different matter and *is* captured and restored.
 - **Discarding the event loop is a fence, not a flush.** `EventLoop.Clear()` can only throw away what is already queued, and the case that matters is the one where nothing is: a fire-and-forget async function suspended on a CLR `Task` enqueues its settle whenever that task happens to complete, which can be after a restore — and the resumed body then writes the previous cycle's data into the restored globals, a cross-cycle channel the fresh-engine-per-evaluation pattern never had. The fix is a generation captured at promise **registration** (engine thread), carried in the `EventLoopJob`, and checked at **dequeue** (engine thread): both ends are ordered by the single-thread contract, where a check inside the settle closure would race the restore. Any new enqueue path must stamp the registering cycle's generation, not the current one, whenever the two can differ. The consequence for hosts is real and documented: a promise registered before a restore never settles into the engine afterwards.
diff --git a/Jint.Tests.PublicInterface/HostAsyncFailureChannelTests.cs b/Jint.Tests.PublicInterface/HostAsyncFailureChannelTests.cs
new file mode 100644
index 0000000000..157f5aca01
--- /dev/null
+++ b/Jint.Tests.PublicInterface/HostAsyncFailureChannelTests.cs
@@ -0,0 +1,383 @@
+#nullable enable
+
+using Jint.Native;
+using Jint.Native.Object;
+using Jint.Runtime;
+
+namespace Jint.Tests.PublicInterface;
+
+/// <summary>
+/// Pins where a failure of an <c>*Async</c> engine entry is delivered.
+/// <para>
+/// The rule: a usage error — a <see langword="null"/> argument, a <see cref="Prepared{TProgram}"/> that did
+/// not come from <c>PrepareScript</c>, and the refusal because the engine is already in use — is thrown out
+/// of the call itself, because it means the operation never started. Everything the operation does —
+/// parsing, running, an execution constraint tripping, a rejected promise — is delivered through the
+/// returned <see cref="Task"/>, so a host that wraps only its <c>await</c> sees all of it.
+/// </para>
+/// <para>
+/// Before this was true, which channel a constraint failure took was decided by a thread race: a charge
+/// landed by a host callback on another thread could trip the post-script check while the engine thread was
+/// still inside the synchronous phase, where no task exists yet, and the exception erupted from the call.
+/// <see cref="AChargeLandedByAnotherThreadBeforeThePostScriptCheckStillFaultsTheTask"/> forces exactly that
+/// ordering, which is why it needs no repetition to be meaningful.
+/// </para>
+/// </summary>
+public class HostAsyncFailureChannelTests
+{
+    private const string ConcurrentUseMessage = "*already in use by another thread or has an asynchronous operation in progress*";
+    private const int AllocationSize = 2_000_000;
+    private const int SingleAllocationBudget = 3_500_000;
+
+    private static readonly TimeSpan HandoffCeiling = TimeSpan.FromSeconds(10);
+
+    // ---------------------------------------------------------------------------------------------
+    // Through the task: everything the operation itself does.
+    // ---------------------------------------------------------------------------------------------
+
+    [Fact]
+    public async Task AStatementBudgetReachesTheTaskRatherThanTheCall()
+    {
+        var engine = new Engine(options => options.MaxStatements(10));
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync("for (var i = 0; i < 1000; i++) { }"));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<StatementsCountOverflowException>();
+    }
+
+    [Fact]
+    public async Task AWallClockBudgetReachesTheTaskRatherThanTheCall()
+    {
+        var engine = new Engine(options => options.TimeoutInterval(TimeSpan.FromMilliseconds(50)));
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync("while (true) { }"));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<TimeoutException>();
+    }
+
+    [Fact]
+    public async Task AnAllocationBudgetReachesTheTaskRatherThanTheCall()
+    {
+        var allocations = new List<byte[]>();
+        var engine = CreateMemoryLimitedEngine(allocations);
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync("allocate(); allocate();"));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<MemoryLimitExceededException>();
+    }
+
+    [Fact]
+    public async Task ARecursionLimitReachesTheTaskRatherThanTheCall()
+    {
+        var engine = new Engine(options => options.LimitRecursion(5));
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync("function f() { return f(); } f();"));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<RecursionDepthOverflowException>();
+    }
+
+    [Fact]
+    public async Task ACancellationConstraintReachesTheTaskRatherThanTheCall()
+    {
+        using var cts = new CancellationTokenSource();
+        var engine = new Engine(options => options.CancellationToken(cts.Token));
+        engine.SetValue("cancel", new Action(cts.Cancel));
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync("cancel(); for (var i = 0; i < 1000000; i++) { }"));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<ExecutionCanceledException>();
+    }
+
+    [Fact]
+    public async Task ASyntaxErrorReachesTheTaskRatherThanTheCall()
+    {
+        var engine = new Engine();
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync("var ="));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<JavaScriptException>();
+        exception!.Message.Should().Contain("Unexpected token");
+    }
+
+    [Fact]
+    public async Task AScriptThrowReachesTheTaskRatherThanTheCall()
+    {
+        var engine = new Engine();
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync("throw new Error('boom')"));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<JavaScriptException>();
+        exception!.Message.Should().Be("boom");
+    }
+
+    [Fact]
+    public async Task ThePreparedScriptOverloadReportsItsBudgetThroughTheTaskToo()
+    {
+        var engine = new Engine(options => options.MaxStatements(10));
+        var prepared = Engine.PrepareScript("for (var i = 0; i < 1000; i++) { }");
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync(prepared));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<StatementsCountOverflowException>();
+    }
+
+    [Fact]
+    public async Task ExecuteAsyncReportsItsBudgetThroughTheTaskToo()
+    {
+        var engine = new Engine(options => options.MaxStatements(10));
+
+        Task<Engine>? pending = null;
+        Invoking(() => { pending = engine.ExecuteAsync("for (var i = 0; i < 1000; i++) { }"); })
+            .Should().NotThrow("a budget failure belongs on the returned task");
+
+        var exception = await Record.ExceptionAsync(() => pending!);
+        exception.Should().BeOfType<StatementsCountOverflowException>();
+    }
+
+    [Fact]
+    public async Task InvokeAsyncReportsItsBudgetThroughTheTaskToo()
+    {
+        var engine = new Engine(options => options.MaxStatements(10));
+        engine.Execute("function work() { for (var i = 0; i < 1000; i++) { } }");
+
+        var pending = StartWithoutThrowing(() => engine.InvokeAsync("work"));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<StatementsCountOverflowException>();
+    }
+
+    [Fact]
+    public async Task InvokeAsyncReportsANonFunctionThroughTheTaskToo()
+    {
+        var engine = new Engine();
+
+        var pending = StartWithoutThrowing(() => engine.InvokeAsync("missing"));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<JavaScriptException>();
+        exception!.Message.Should().Be("Can only invoke functions");
+    }
+
+    [Fact]
+    public async Task ImportAsyncReportsItsBudgetThroughTheTaskToo()
+    {
+        var engine = new Engine(options => options.MaxStatements(10));
+        engine.Modules.Add("module", builder => builder.AddSource("for (var i = 0; i < 1000; i++) { }"));
+
+        Task<ObjectInstance>? pending = null;
+        Invoking(() => { pending = engine.Modules.ImportAsync("module"); })
+            .Should().NotThrow("a budget failure belongs on the returned task");
+
+        var exception = await Record.ExceptionAsync(() => pending!);
+        exception.Should().BeOfType<StatementsCountOverflowException>();
+    }
+
+    // ---------------------------------------------------------------------------------------------
+    // The race the issue reports, forced into a deterministic ordering.
+    // ---------------------------------------------------------------------------------------------
+
+    /// <summary>
+    /// The mechanism behind <c>HostMemoryLimitTests.TransferredHostCallbackCountsAllocationsOnItsThread</c>:
+    /// a host callback running on another thread is charged to the same operation, and if its charge lands
+    /// before the engine thread reaches <c>ScriptEvaluation</c>'s post-script check, the check trips inside
+    /// the synchronous phase. Joining the other thread inside the host function forces that ordering on every
+    /// run, so this fails deterministically against an engine that reports such a failure synchronously.
+    /// </summary>
+    [Fact]
+    public async Task AChargeLandedByAnotherThreadBeforeThePostScriptCheckStillFaultsTheTask()
+    {
+        var allocations = new List<byte[]>();
+        var engine = CreateMemoryLimitedEngine(allocations);
+        engine.SetValue("schedule", new Func<Func<int>, Task<int>>(callback =>
+        {
+            // The flaky test hands the pool thread's task straight back and lets the two threads race.
+            // Waiting for it here is the whole of the difference: the pool thread's allocation is charged
+            // to this operation before the engine thread returns, so it is always the post-script check
+            // that trips, and always inside the synchronous phase.
+            var scheduled = Task.Run(callback);
+            scheduled.Wait();
+            return scheduled;
+        }));
+
+        var pending = StartWithoutThrowing(() => engine.EvaluateAsync("""
+            (async () => {
+                allocate();
+                return await schedule(() => {
+                    allocate();
+                    return 42;
+                });
+            })()
+            """));
+
+        var exception = await Record.ExceptionAsync(() => pending);
+        exception.Should().BeOfType<MemoryLimitExceededException>();
+    }
+
+    // ---------------------------------------------------------------------------------------------
+    // The constraint is unchanged: same type, same message, still fatal, and the engine recovers.
+    // ---------------------------------------------------------------------------------------------
+
+    [Fact]
+    public async Task TheTaskCarriesTheSameExceptionTheSynchronousEntryThrows()
+    {
+        const string Script = "globalThis.marker = 1; for (var i = 0; i < 1000; i++) { } globalThis.finished = true;";
+
+        var synchronous = new Engine(options => options.MaxStatements(10));
+        var fromEvaluate = Record.Exception(() => synchronous.Evaluate(Script));
+
+        var asynchronous = new Engine(options => options.MaxStatements(10));
+        var fromEvaluateAsync = await Record.ExceptionAsync(() => asynchronous.EvaluateAsync(Script));
+
+        fromEvaluate.Should().BeOfType<StatementsCountOverflowException>();
+        fromEvaluateAsync.Should().BeOfType<StatementsCountOverflowException>();
+        fromEvaluateAsync!.Message.Should().Be(fromEvaluate!.Message);
+
+        // Still fatal, not something the script rides through: the statement after the loop never ran.
+        asynchronous.Evaluate("typeof globalThis.marker").AsString().Should().Be("number");
+        asynchronous.Evaluate("typeof globalThis.finished").AsString().Should().Be("undefined");
+    }
+
+    [Fact]
+    public async Task TheEngineIsUsableAgainAfterATaskFaultedBudgetFailure()
+    {
+        var engine = new Engine(options => options.MaxStatements(50));
+
+        var first = await Record.ExceptionAsync(() => engine.EvaluateAsync("for (var i = 0; i < 1000; i++) { }"));
+        first.Should().BeOfType<StatementsCountOverflowException>();
+
+        // The reservation is released by the body's finally even when the body never reached an await, so a
+        // faulted task does not leave the engine claimed for ever.
+        engine.Evaluate("1 + 1").AsNumber().Should().Be(2);
+        var second = await engine.EvaluateAsync("2 + 2");
+        second.AsNumber().Should().Be(4);
+    }
+
+    [Fact]
+    public async Task TheBudgetStillFiresWhenTheFailureOnlyReachesTheTask()
+    {
+        var engine = new Engine(options => options.MaxStatements(10));
+
+        // The shape the issue names as the one a host actually writes: the call is not wrapped, only the
+        // await is. The budget must still fire, and it must land here.
+        var pending = engine.EvaluateAsync("for (var i = 0; i < 1000; i++) { globalThis.ran = i; }");
+
+        var caught = false;
+        try
+        {
+            await pending;
+        }
+        catch (StatementsCountOverflowException)
+        {
+            caught = true;
+        }
+
+        caught.Should().BeTrue("the constraint must still be fatal, only delivered elsewhere");
+        engine.Evaluate("globalThis.ran").AsNumber().Should().BeLessThan(1000);
+    }
+
+    // ---------------------------------------------------------------------------------------------
+    // Out of the call: usage errors, which say the operation never started.
+    // ---------------------------------------------------------------------------------------------
+
+    [Fact]
+    public void ANullScriptIsRefusedSynchronously()
+    {
+        var engine = new Engine();
+
+        Invoking(() => { _ = engine.EvaluateAsync(null!); })
+            .Should().Throw<ArgumentNullException>().WithParameterName("code");
+        Invoking(() => { _ = engine.ExecuteAsync(null!); })
+            .Should().Throw<ArgumentNullException>().WithParameterName("code");
+
+        // Nothing was reserved, so the engine is still free.
+        engine.Evaluate("1 + 1").AsNumber().Should().Be(2);
+    }
+
+    [Fact]
+    public void ANullInvokeArgumentIsRefusedSynchronously()
+    {
+        var engine = new Engine();
+        engine.Execute("function work() { }");
+
+        Invoking(() => { _ = engine.InvokeAsync(null!); })
+            .Should().Throw<ArgumentNullException>().WithParameterName("propertyName");
+        Invoking(() => { _ = engine.InvokeAsync("work", (object?[]) null!); })
+            .Should().Throw<ArgumentNullException>().WithParameterName("arguments");
+
+        engine.Evaluate("1 + 1").AsNumber().Should().Be(2);
+    }
+
+    [Fact]
+    public void AnUnpreparedScriptIsRefusedSynchronously()
+    {
+        var engine = new Engine();
+
+        Invoking(() => { _ = engine.EvaluateAsync(default(Prepared<Script>)); })
+            .Should().Throw<ArgumentException>().WithParameterName("preparedScript");
+
+        engine.Evaluate("1 + 1").AsNumber().Should().Be(2);
+    }
+
+    [Fact]
+    public async Task EveryAsyncEntryRefusesAConcurrentCallSynchronously()
+    {
+        using var entered = new ManualResetEventSlim();
+        using var release = new ManualResetEventSlim();
+        var engine = new Engine();
+        engine.Modules.Add("module", builder => builder.AddSource("export const value = 1;"));
+        engine.SetValue("block", new Action(() =>
+        {
+            entered.Set();
+            release.Wait();
+        }));
+        engine.Execute("function work() { }");
+        var prepared = Engine.PrepareScript("1");
+
+        var running = DedicatedThread.RunAsync(() => engine.Execute("block()"));
+        entered.Wait(HandoffCeiling).Should().BeTrue("the owning thread did not enter block()");
+        try
+        {
+            Invoking(() => { _ = engine.EvaluateAsync("1"); })
+                .Should().Throw<InvalidOperationException>().WithMessage(ConcurrentUseMessage);
+            Invoking(() => { _ = engine.EvaluateAsync(prepared); })
+                .Should().Throw<InvalidOperationException>().WithMessage(ConcurrentUseMessage);
+            Invoking(() => { _ = engine.ExecuteAsync("1"); })
+                .Should().Throw<InvalidOperationException>().WithMessage(ConcurrentUseMessage);
+            Invoking(() => { _ = engine.InvokeAsync("work"); })
+                .Should().Throw<InvalidOperationException>().WithMessage(ConcurrentUseMessage);
+            Invoking(() => { _ = engine.Modules.ImportAsync("module"); })
+                .Should().Throw<InvalidOperationException>().WithMessage(ConcurrentUseMessage);
+        }
+        finally
+        {
+            release.Set();
+        }
+
+        await running;
+        engine.Evaluate("1 + 1").AsNumber().Should().Be(2);
+    }
+
+    private static Task<JsValue> StartWithoutThrowing(Func<Task<JsValue>> start)
+    {
+        Task<JsValue>? pending = null;
+        Invoking(() => { pending = start(); })
+            .Should().NotThrow("the failure of the operation belongs on the returned task, not on the call");
+        return pending!;
+    }
+
+    private static Engine CreateMemoryLimitedEngine(List<byte[]> allocations)
+    {
+        var engine = new Engine(options => options.LimitMemory(SingleAllocationBudget));
+        engine.SetValue("allocate", new Action(() => allocations.Add(new byte[AllocationSize])));
+        return engine;
+    }
+
+}
diff --git a/Jint.Tests.PublicInterface/HostMemoryLimitTests.cs b/Jint.Tests.PublicInterface/HostMemoryLimitTests.cs
index c20e45eff3..f0e245d34b 100644
--- a/Jint.Tests.PublicInterface/HostMemoryLimitTests.cs
+++ b/Jint.Tests.PublicInterface/HostMemoryLimitTests.cs
@@ -116,17 +116,25 @@ public async Task TransferredHostCallbackCountsAllocationsOnItsThread()
         var engine = CreateEngine(allocations);
         engine.SetValue("schedule", new Func<Func<int>, Task<int>>(callback => Task.Run(callback)));
 
-        var pending = engine.EvaluateAsync("""
-            (async () => {
-                allocate();
-                return await schedule(() => {
+        // The call itself is asserted not to throw, not merely left unwrapped: whether the pool thread's
+        // charge lands before or after the engine thread's post-script check decides where the failure is
+        // raised, and only the task is an acceptable answer. See HostAsyncFailureChannelTests.
+        Task<JsValue>? pending = null;
+        Invoking(() =>
+        {
+            pending = engine.EvaluateAsync("""
+                (async () => {
                     allocate();
-                    return 42;
-                });
-            })()
-            """);
-
-        var exception = await Record.ExceptionAsync(() => pending);
+                    return await schedule(() => {
+                        allocate();
+                        return 42;
+                    });
+                })()
+                """);
+        })
+            .Should().NotThrow("a budget failure belongs on the returned task, whichever thread trips it");
+
+        var exception = await Record.ExceptionAsync(() => pending!);
         exception.Should().BeOfType<MemoryLimitExceededException>();
     }
 
diff --git a/Jint/Engine.Async.cs b/Jint/Engine.Async.cs
index c9de817e7d..eeb8eb4d24 100644
--- a/Jint/Engine.Async.cs
+++ b/Jint/Engine.Async.cs
@@ -9,6 +9,24 @@ namespace Jint;
 
 public partial class Engine
 {
+    // INVARIANT for every entry in this file: the public method validates its arguments and takes the
+    // reservation, and then hands off to a `private async` body that owns the release in a finally. The
+    // split is the failure channel, and both halves of it are load-bearing.
+    //
+    // A usage error - a null argument, an unprepared script, and ReserveAsyncHostOperation refusing because
+    // the engine is already in use - says the operation never started, so it belongs on the caller's stack;
+    // there is no evaluation for a task to describe, and Advanced.WaitForScheduledWorkAsync reserves
+    // synchronously for the same reason. Everything else says the operation started and failed, and belongs
+    // on the returned task: an async body captures its own synchronous phase, which is exactly what makes
+    // that true for the parse and for the whole synchronous run of the script.
+    //
+    // So do NOT move a reservation into a body, and do NOT hoist work out of one. Before the split, the
+    // family was divided by nothing more than which methods happened to be declared `async`: ExecuteAsync
+    // was, so a tripped constraint reached its task, while EvaluateAsync was not, so the identical failure
+    // on the identical script erupted from the call - and erupted only sometimes, because a host callback
+    // charged to the operation from another thread could trip the post-script check before the engine thread
+    // reached it. See https://github.com/sebastienros/jint/issues/3241.
+
     /// <summary>
     /// Evaluates JavaScript code asynchronously, properly awaiting any promises.
     /// This is the non-blocking alternative to Evaluate() + UnwrapIfPromise().
@@ -16,6 +34,16 @@ public partial class Engine
     /// thread is released and zero threads are consumed until work is available.
     /// </summary>
     /// <remarks>
+    /// <para>
+    /// <b>Where failures arrive.</b> Everything the evaluation itself does — parsing, running the script,
+    /// an execution constraint tripping, a rejected promise — is reported through the returned
+    /// <see cref="Task{TResult}"/> and never thrown out of this call, so a <c>catch</c> around the
+    /// <c>await</c> sees all of it however far the evaluation got before failing. Only a usage error
+    /// arrives synchronously: a <see langword="null"/> argument, and the
+    /// <see cref="InvalidOperationException"/> refusing the call because the engine is already in use.
+    /// Both mean the operation never started, so there is no evaluation for a task to describe.
+    /// </para>
+    /// <para>
     /// <paramref name="cancellationToken"/> does <b>not</b> preempt the synchronous evaluation loop. The
     /// script is evaluated to completion first and the token is only observed afterwards, while awaiting
     /// promise settlement — that is, at event-loop continuation boundaries. A script that never yields
@@ -24,36 +52,58 @@ public partial class Engine
     /// <see cref="ConstraintsOptionsExtensions.CancellationToken"/> for token-driven cancellation or
     /// <see cref="ConstraintsOptionsExtensions.TimeoutInterval"/> for a wall-clock bound. Both are
     /// amortizable, so neither disarms the interpreter's tight-loop lane.
+    /// </para>
     /// </remarks>
     /// <param name="code">The JavaScript code to evaluate.</param>
     /// <param name="source">Optional source identifier for debugging.</param>
     /// <param name="cancellationToken">Cancellation token to observe while awaiting promise settlement; see the remarks.</param>
     /// <returns>The resolved value if the result is a promise, otherwise the direct result.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="code"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">This engine is already in use.</exception>
     public Task<JsValue> EvaluateAsync(string code, string? source = null, CancellationToken cancellationToken = default)
     {
+        if (code is null)
+        {
+            Throw.ArgumentNullException(nameof(code));
+        }
+
         var owner = ReserveAsyncHostOperation();
-        Task<JsValue> task;
+        return EvaluateOnReservationAsync(code, source, owner, cancellationToken);
+    }
+
+    private async Task<JsValue> EvaluateOnReservationAsync(string code, string? source, object owner, CancellationToken cancellationToken)
+    {
         try
         {
+            Task<JsValue> task;
             using (EnterHostCall(owner))
             {
-                var result = Evaluate(code, source);
-                task = UnwrapResultAsync(result, owner, cancellationToken);
+                task = UnwrapResultAsync(Evaluate(code, source), owner, cancellationToken);
             }
+
+            return await task.ConfigureAwait(false);
         }
-        catch
+        finally
         {
             ReleaseAsyncHostOperation(owner);
-            throw;
         }
-
-        return CompleteAsyncHostOperation(task, owner);
     }
 
     /// <summary>
     /// Evaluates a prepared script asynchronously, properly awaiting any promises.
     /// </summary>
     /// <remarks>
+    /// <para>
+    /// <b>Where failures arrive.</b> Everything the evaluation itself does — running the script, an
+    /// execution constraint tripping, a rejected promise — is reported through the returned
+    /// <see cref="Task{TResult}"/> and never thrown out of this call, so a <c>catch</c> around the
+    /// <c>await</c> sees all of it however far the evaluation got before failing. Only a usage error
+    /// arrives synchronously: a <paramref name="preparedScript"/> that did not come from
+    /// <c>PrepareScript</c>, and the
+    /// <see cref="InvalidOperationException"/> refusing the call because the engine is already in use.
+    /// Both mean the operation never started, so there is no evaluation for a task to describe.
+    /// </para>
+    /// <para>
     /// <paramref name="cancellationToken"/> does <b>not</b> preempt the synchronous evaluation loop. The
     /// script is evaluated to completion first and the token is only observed afterwards, while awaiting
     /// promise settlement — that is, at event-loop continuation boundaries. A script that never yields
@@ -62,29 +112,41 @@ public Task<JsValue> EvaluateAsync(string code, string? source = null, Cancellat
     /// <see cref="ConstraintsOptionsExtensions.CancellationToken"/> for token-driven cancellation or
     /// <see cref="ConstraintsOptionsExtensions.TimeoutInterval"/> for a wall-clock bound. Both are
     /// amortizable, so neither disarms the interpreter's tight-loop lane.
+    /// </para>
     /// </remarks>
     /// <param name="preparedScript">The pre-parsed script to evaluate.</param>
     /// <param name="cancellationToken">Cancellation token to observe while awaiting promise settlement; see the remarks.</param>
     /// <returns>The resolved value if the result is a promise, otherwise the direct result.</returns>
+    /// <exception cref="ArgumentException"><paramref name="preparedScript"/> did not come from <c>PrepareScript</c>.</exception>
+    /// <exception cref="InvalidOperationException">This engine is already in use.</exception>
     public Task<JsValue> EvaluateAsync(in Prepared<Script> preparedScript, CancellationToken cancellationToken = default)
     {
+        if (!preparedScript.IsValid)
+        {
+            Throw.InvalidPreparedScriptArgumentException(nameof(preparedScript));
+        }
+
+        var prepared = preparedScript;
         var owner = ReserveAsyncHostOperation();
-        Task<JsValue> task;
+        return EvaluateOnReservationAsync(prepared, owner, cancellationToken);
+    }
+
+    private async Task<JsValue> EvaluateOnReservationAsync(Prepared<Script> preparedScript, object owner, CancellationToken cancellationToken)
+    {
         try
         {
+            Task<JsValue> task;
             using (EnterHostCall(owner))
             {
-                var result = Evaluate(in preparedScript);
-                task = UnwrapResultAsync(result, owner, cancellationToken);
+                task = UnwrapResultAsync(Evaluate(in preparedScript), owner, cancellationToken);
             }
+
+            return await task.ConfigureAwait(false);
         }
-        catch
+        finally
         {
             ReleaseAsyncHostOperation(owner);
-            throw;
         }
-
-        return CompleteAsyncHostOperation(task, owner);
     }
 
     /// <summary>
@@ -92,44 +154,67 @@ public Task<JsValue> EvaluateAsync(in Prepared<Script> preparedScript, Cancellat
     /// This is the non-blocking alternative to Execute() when the code may contain async operations.
     /// </summary>
     /// <remarks>
+    /// <para>
+    /// <b>Where failures arrive.</b> Everything the execution itself does — parsing, running the code, an
+    /// execution constraint tripping, a rejected promise — is reported through the returned
+    /// <see cref="Task{TResult}"/> and never thrown out of this call. Only a usage error arrives
+    /// synchronously: a <see langword="null"/> argument, and the <see cref="InvalidOperationException"/>
+    /// refusing the call because the engine is already in use.
+    /// </para>
+    /// <para>
     /// <paramref name="cancellationToken"/> does <b>not</b> preempt the synchronous evaluation loop. The
     /// code runs to completion first and the token is only observed afterwards, while awaiting promise
     /// settlement — that is, at event-loop continuation boundaries. To bound the interpreter itself,
     /// register an execution constraint on the engine's <see cref="Options"/>:
     /// <see cref="ConstraintsOptionsExtensions.CancellationToken"/> or
     /// <see cref="ConstraintsOptionsExtensions.TimeoutInterval"/>.
+    /// </para>
     /// </remarks>
     /// <param name="code">The JavaScript code to execute.</param>
     /// <param name="source">Optional source identifier for debugging.</param>
     /// <param name="cancellationToken">Cancellation token to observe while awaiting promise settlement; see the remarks.</param>
     /// <returns>The engine instance for chaining, after all async work completes.</returns>
-    public async Task<Engine> ExecuteAsync(string code, string? source = null, CancellationToken cancellationToken = default)
+    /// <exception cref="ArgumentNullException"><paramref name="code"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">This engine is already in use.</exception>
+    public Task<Engine> ExecuteAsync(string code, string? source = null, CancellationToken cancellationToken = default)
     {
+        if (code is null)
+        {
+            Throw.ArgumentNullException(nameof(code));
+        }
+
         var owner = ReserveAsyncHostOperation();
-        Task<JsValue> task;
+        return ExecuteOnReservationAsync(code, source, owner, cancellationToken);
+    }
+
+    private async Task<Engine> ExecuteOnReservationAsync(string code, string? source, object owner, CancellationToken cancellationToken)
+    {
         try
         {
+            Task<JsValue> task;
             using (EnterHostCall(owner))
             {
-                var result = Evaluate(code, source);
-                task = UnwrapResultAsync(result, owner, cancellationToken);
+                task = UnwrapResultAsync(Evaluate(code, source), owner, cancellationToken);
             }
+
+            await task.ConfigureAwait(false);
+            return this;
         }
-        catch
+        finally
         {
             ReleaseAsyncHostOperation(owner);
-            throw;
         }
-
-        return await CompleteExecuteAsync(task, owner).ConfigureAwait(false);
     }
 
     /// <summary>
     /// Invokes a JavaScript function asynchronously, properly awaiting any returned promise.
     /// </summary>
+    /// <inheritdoc cref="InvokeAsync(string, CancellationToken, object[])" path="/remarks"/>
     /// <param name="propertyName">The name of the function to invoke.</param>
     /// <param name="arguments">Arguments to pass to the function.</param>
     /// <returns>The resolved value if the function returns a promise, otherwise the direct result.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="propertyName"/> or <paramref name="arguments"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">This engine is already in use.</exception>
     public Task<JsValue> InvokeAsync(string propertyName, params object?[] arguments)
     {
         return InvokeAsync(propertyName, CancellationToken.None, arguments);
@@ -139,56 +224,55 @@ public Task<JsValue> InvokeAsync(string propertyName, params object?[] arguments
     /// Invokes a JavaScript function asynchronously, properly awaiting any returned promise.
     /// </summary>
     /// <remarks>
+    /// <para>
+    /// <b>Where failures arrive.</b> Everything the call itself does — resolving the name, running the
+    /// function, an execution constraint tripping, a rejected promise — is reported through the returned
+    /// <see cref="Task{TResult}"/> and never thrown out of this call. Only a usage error arrives
+    /// synchronously: a <see langword="null"/> argument, and the <see cref="InvalidOperationException"/>
+    /// refusing the call because the engine is already in use.
+    /// </para>
+    /// <para>
     /// <paramref name="cancellationToken"/> does <b>not</b> preempt the synchronous call. The function runs
     /// to completion first and the token is only observed afterwards, while awaiting promise settlement —
     /// that is, at event-loop continuation boundaries. To bound the interpreter itself, register an
     /// execution constraint on the engine's <see cref="Options"/>:
     /// <see cref="ConstraintsOptionsExtensions.CancellationToken"/> or
     /// <see cref="ConstraintsOptionsExtensions.TimeoutInterval"/>.
+    /// </para>
     /// </remarks>
     /// <param name="propertyName">The name of the function to invoke.</param>
     /// <param name="cancellationToken">Cancellation token to observe while awaiting promise settlement; see the remarks.</param>
     /// <param name="arguments">Arguments to pass to the function.</param>
     /// <returns>The resolved value if the function returns a promise, otherwise the direct result.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="propertyName"/> or <paramref name="arguments"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">This engine is already in use.</exception>
     public Task<JsValue> InvokeAsync(string propertyName, CancellationToken cancellationToken, params object?[] arguments)
     {
-        var owner = ReserveAsyncHostOperation();
-        Task<JsValue> task;
-        try
+        if (propertyName is null)
         {
-            using (EnterHostCall(owner))
-            {
-                var result = Invoke(propertyName, arguments);
-                task = UnwrapResultAsync(result, owner, cancellationToken);
-            }
+            Throw.ArgumentNullException(nameof(propertyName));
         }
-        catch
+
+        if (arguments is null)
         {
-            ReleaseAsyncHostOperation(owner);
-            throw;
+            Throw.ArgumentNullException(nameof(arguments));
         }
 
-        return CompleteAsyncHostOperation(task, owner);
+        var owner = ReserveAsyncHostOperation();
+        return InvokeOnReservationAsync(propertyName, arguments, owner, cancellationToken);
     }
 
-    private async Task<JsValue> CompleteAsyncHostOperation(Task<JsValue> task, object owner)
+    private async Task<JsValue> InvokeOnReservationAsync(string propertyName, object?[] arguments, object owner, CancellationToken cancellationToken)
     {
         try
         {
-            return await task.ConfigureAwait(false);
-        }
-        finally
-        {
-            ReleaseAsyncHostOperation(owner);
-        }
-    }
+            Task<JsValue> task;
+            using (EnterHostCall(owner))
+            {
+                task = UnwrapResultAsync(Invoke(propertyName, arguments), owner, cancellationToken);
+            }
 
-    private async Task<Engine> CompleteExecuteAsync(Task<JsValue> task, object owner)
-    {
-        try
-        {
-            await task.ConfigureAwait(false);
-            return this;
+            return await task.ConfigureAwait(false);
         }
         finally
         {
@@ -203,6 +287,11 @@ private async Task<Engine> CompleteExecuteAsync(Task<JsValue> task, object owner
     internal Task<JsValue> UnwrapResultAsync(JsValue result, CancellationToken cancellationToken)
     {
         var owner = ReserveAsyncHostOperation();
+        return UnwrapOnReservationAsync(result, owner, cancellationToken);
+    }
+
+    private async Task<JsValue> UnwrapOnReservationAsync(JsValue result, object owner, CancellationToken cancellationToken)
+    {
         try
         {
             Task<JsValue> task;
@@ -211,12 +300,11 @@ internal Task<JsValue> UnwrapResultAsync(JsValue result, CancellationToken cance
                 task = UnwrapResultAsync(result, owner, cancellationToken);
             }
 
-            return CompleteAsyncHostOperation(task, owner);
+            return await task.ConfigureAwait(false);
         }
-        catch
+        finally
         {
             ReleaseAsyncHostOperation(owner);
-            throw;
         }
     }
 
diff --git a/Jint/Engine.Modules.cs b/Jint/Engine.Modules.cs
index cfb340d304..d73b53731e 100644
--- a/Jint/Engine.Modules.cs
+++ b/Jint/Engine.Modules.cs
@@ -1039,46 +1039,56 @@ private ModuleImportOperation StartImportCore(string specifier, string? referenc
         /// <see cref="IAsyncModuleLoader"/>.
         /// </summary>
         /// <remarks>
+        /// <para>
         /// The engine is single-threaded and this method does not change that: continuations run one at a time,
         /// on whichever thread resumes the await. A host with a thread affinity — a game loop, a UI thread —
         /// wants <see cref="StartImport(string)"/> and its own pump instead, so that every turn runs where the
         /// host needs it to.
+        /// </para>
+        /// <para>
+        /// <b>Where failures arrive.</b> Everything the import itself does — resolving and loading the graph,
+        /// linking it, evaluating it, an execution constraint tripping — is reported through the returned
+        /// <see cref="Task{TResult}"/> and never thrown out of this call, so a <c>catch</c> around the
+        /// <c>await</c> sees all of it. Only the <see cref="InvalidOperationException"/> refusing the call
+        /// because the engine is already in use arrives synchronously; it means the import never started, so
+        /// there is nothing for a task to describe.
+        /// </para>
         /// </remarks>
         /// <exception cref="PromiseRejectedException">The module failed to load or its evaluation threw.</exception>
+        /// <exception cref="InvalidOperationException">This engine is already in use.</exception>
         public Task<ObjectInstance> ImportAsync(string specifier, CancellationToken cancellationToken = default)
             => ImportAsync(specifier, referencingModuleLocation: null, cancellationToken);
 
         /// <inheritdoc cref="ImportAsync(string,CancellationToken)" />
-        public async Task<ObjectInstance> ImportAsync(string specifier, string? referencingModuleLocation, CancellationToken cancellationToken = default)
+        public Task<ObjectInstance> ImportAsync(string specifier, string? referencingModuleLocation, CancellationToken cancellationToken = default)
         {
+            // Taken here rather than inside the async body so that the admission failure is reported to the
+            // caller synchronously, exactly as EvaluateAsync and its siblings report it; the body owns the
+            // release, and every other way the import can fail belongs to the returned task.
             var owner = _engine.ReserveAsyncHostOperation();
-            Task<JsValue> task;
+            return ImportOnReservationAsync(specifier, referencingModuleLocation, owner, cancellationToken);
+        }
+
+        private async Task<ObjectInstance> ImportOnReservationAsync(
+            string specifier,
+            string? referencingModuleLocation,
+            object owner,
+            CancellationToken cancellationToken)
+        {
             try
             {
+                Task<JsValue> task;
                 using (_engine.EnterHostCall(owner))
                 {
                     var promise = StartImport(specifier, referencingModuleLocation).Promise;
                     task = _engine.UnwrapResultAsync(promise, owner, cancellationToken);
                 }
-            }
-            catch
-            {
-                _engine.ReleaseAsyncHostOperation(owner);
-                throw;
-            }
-
-            return await CompleteImportAsync(task, _engine, owner).ConfigureAwait(false);
-        }
 
-        private static async Task<ObjectInstance> CompleteImportAsync(Task<JsValue> task, Engine engine, object owner)
-        {
-            try
-            {
                 return (ObjectInstance) await task.ConfigureAwait(false);
             }
             finally
             {
-                engine.ReleaseAsyncHostOperation(owner);
+                _engine.ReleaseAsyncHostOperation(owner);
             }
         }
 
diff --git a/README.md b/README.md
index 968d43507e..b6a5d18331 100644
--- a/README.md
+++ b/README.md
@@ -3259,6 +3259,36 @@ using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
 var result = await engine.EvaluateAsync("(async () => await fetchData(url))()", cancellationToken: cts.Token);
 ```
 
+#### Where failures arrive
+
+Everything the operation itself does — parsing, running the script, an execution constraint tripping, a
+Promise rejecting — is reported through the returned `Task`. So the `catch` goes around the `await`, and it
+does not matter whether you await the call directly or hold the `Task` and await it later:
+
+```c#
+var pending = engine.EvaluateAsync(untrustedScript);   // never throws the script's failure
+try
+{
+    var result = await pending;                        // every failure of the evaluation lands here
+}
+catch (MemoryLimitExceededException)                   // ... including a budget you configured
+{
+}
+```
+
+Only a *usage error* is thrown out of the call itself, because it means the operation never started and
+there is no evaluation for a `Task` to describe:
+
+* a `null` argument (`ArgumentNullException`), or a `Prepared<Script>` that did not come from
+  `PrepareScript` (`ArgumentException`);
+* `InvalidOperationException` refusing the call because this engine is already in use by another operation
+  — an `Engine` serves one host operation at a time.
+
+This holds for `EvaluateAsync`, `ExecuteAsync`, `InvokeAsync`, `Modules.ImportAsync`,
+`Advanced.WaitForScheduledWorkAsync` and `UnwrapIfPromiseAsync` alike. Constraints are unaffected by it:
+the same exception type and message still fire, and still abort the run — only which channel delivers them
+is now fixed rather than decided by which thread got there first.
+
 ### UnwrapIfPromiseAsync
 
 When you already hold a `JsValue` that may be a Promise — for example returned from `engine.Invoke(...)`, `value.Call(...)`, or a property access — use `UnwrapIfPromiseAsync` to await it without blocking: