one left!

Author: rogeralsing

src/Asynkron.JsEngine/Ast/AwaitExpressionExtensions.cs

@@ -1,4 +1,5 @@
 using Asynkron.JsEngine.Execution;
+using Asynkron.JsEngine.JsTypes;
 
 namespace Asynkron.JsEngine.Ast;
 
@@ -26,15 +27,42 @@ public static partial class TypedAstEvaluator
                 return awaited;
             }
 
-            // For top-level await (module level, no generator), use synchronous blocking.
-            // This ensures promises are resolved before continuing.
-            if (!AwaitScheduler.TryAwaitPromiseSync(awaited, context, out var resolved))
+            // Always await asynchronously: wrap non-promises with Promise.resolve and drive through scheduler.
+            if (awaited is not JsObject jsObj || !AwaitScheduler.IsPromiseLike(jsObj))
             {
-                // TryAwaitPromiseSync returns false if there was a rejection that set context.IsThrow
-                return resolved;
+                var promiseCtor = context.RealmState.PromiseConstructor;
+                JsObject? wrappedPromise = null;
+
+                if (promiseCtor is IJsPropertyAccessor accessor &&
+                    accessor.TryGetProperty("resolve", out var resolveValue) &&
+                    resolveValue is IJsCallable resolveCallable &&
+                    resolveCallable.Invoke([awaited], promiseCtor as object) is JsObject resolvedPromise)
+                {
+                    wrappedPromise = resolvedPromise;
+                }
+
+                if (wrappedPromise is null)
+                {
+                    // Fallback: create a resolved promise in the current realm.
+                    var engine = context.RealmState.Engine;
+                    var promise = engine?.CreateRealmPromise();
+                    promise?.Resolve(awaited);
+                    wrappedPromise = promise?.JsObject;
+                }
+
+                awaited = wrappedPromise ?? awaited;
+            }
+
+            if (!AwaitScheduler.TryAwaitPromiseSync(
+                    awaited,
+                    context,
+                    out var resolvedValue,
+                    context.DrainAwaitMicrotasks))
+            {
+                return resolvedValue;
             }
 
-            return resolved;
+            return resolvedValue;
         }
 
         private Symbol? GetAwaitStateKey()

src/Asynkron.JsEngine/Ast/JsObjectExtensions.cs

@@ -175,7 +175,11 @@ private void IteratorClose(EvaluationContext context, bool preserveExistingThrow
 
                 if (IsPromiseLike(returnObject))
                 {
-                    AwaitScheduler.TryAwaitPromiseSync(returnObject, context, out _);
+                    AwaitScheduler.TryAwaitPromiseSync(
+                        returnObject,
+                        context,
+                        out _,
+                        context.DrainAwaitMicrotasks);
                 }
             }
             catch (ThrowSignal)

src/Asynkron.JsEngine/Ast/ProgramNodeExtensions.cs

@@ -18,7 +18,8 @@ public static partial class TypedAstEvaluator
         ExecutionKind executionKind = ExecutionKind.Script,
         bool createStrictEnvironment = true,
         Symbol? functionNameHint = null,
-        ImmutableArray<PrivateNameScope>? inheritedPrivateNameScopes = null)
+        ImmutableArray<PrivateNameScope>? inheritedPrivateNameScopes = null,
+        bool drainAwaitMicrotasks = true)
     {
         var context = realmState.CreateContext(
             ScopeKind.Program,
@@ -27,6 +28,7 @@ public static partial class TypedAstEvaluator
             cancellationToken,
             executionKind,
             false);
+        context.DrainAwaitMicrotasks = drainAwaitMicrotasks;
         if (inheritedPrivateNameScopes is { IsDefault: false, Length: > 0 } scopes)
         {
             context.EnterPrivateNameScopes(scopes);

src/Asynkron.JsEngine/Ast/TypedAstEvaluator.DelegatedYieldState.cs

@@ -157,7 +157,11 @@ public static DelegatedYieldState FromEnumerable(IEnumerable<object?> enumerable
                     if (nextCandidate is IJsObjectLike promiseCandidate && IsPromiseLike(promiseCandidate))
                     {
                         awaitedPromise = true;
-                        if (!AwaitScheduler.TryAwaitPromiseSync(promiseCandidate, context, out awaitedCandidate))
+                        if (!AwaitScheduler.TryAwaitPromiseSync(
+                                promiseCandidate,
+                                context,
+                                out awaitedCandidate,
+                                context.DrainAwaitMicrotasks))
                         {
                             return (Symbol.Undefined, true, true, propagateThrow, null);
                         }

src/Asynkron.JsEngine/Ast/TypedAstEvaluator.cs

@@ -177,7 +177,11 @@ private static object NormalizeIterableTarget(object? value, EvaluationContext c
     // pipeline is in place.
     private static bool TryAwaitPromise(object? candidate, EvaluationContext context, out object? resolvedValue)
     {
-        return AwaitScheduler.TryAwaitPromiseSync(candidate, context, out resolvedValue);
+        return AwaitScheduler.TryAwaitPromiseSync(
+            candidate,
+            context,
+            out resolvedValue,
+            context.DrainAwaitMicrotasks);
     }
 
 

src/Asynkron.JsEngine/EvaluationContext.cs

@@ -142,6 +142,13 @@ public sealed class EvaluationContext(
     /// </summary>
     public bool IsThrow => CurrentSignal is ThrowFlowSignal;
 
+    /// <summary>
+    ///     Controls whether await expressions should synchronously drain the microtask queue
+    ///     to resolve promises. For non-blocking top-level await we defer draining until
+    ///     the host resumes the job.
+    /// </summary>
+    public bool DrainAwaitMicrotasks { get; set; } = true;
+
     /// <summary>
     ///     Returns true if the current signal is Yield.
     /// </summary>

src/Asynkron.JsEngine/Execution/AwaitScheduler.cs

@@ -1,3 +1,4 @@
+using System.Threading;
 using Asynkron.JsEngine.Ast;
 using Asynkron.JsEngine.JsTypes;
 
@@ -17,15 +18,22 @@ public static bool IsPromiseLike(object? candidate)
                thenValue is IJsCallable;
     }
 
-    public static bool TryAwaitPromiseSync(object? candidate, EvaluationContext context, out object? resolvedValue)
+    public static bool TryAwaitPromiseSync(
+        object? candidate,
+        EvaluationContext context,
+        out object? resolvedValue,
+        bool drainMicrotasks = true)
     {
         resolvedValue = candidate;
 
-        // Drain any pending microtasks first - this may resolve the promise we're about to await
         var engine = context.RealmState?.Engine;
-        engine?.DrainMicrotasks();
+        if (drainMicrotasks)
+        {
+            engine?.DrainMicrotasks();
+        }
 
-        if (candidate is JsPromise jsPromise &&
+        if (drainMicrotasks &&
+            candidate is JsPromise jsPromise &&
             jsPromise.TryGetSettled(out var settledValue, out var isRejected))
         {
             if (isRejected)
@@ -41,7 +49,8 @@ public static bool TryAwaitPromiseSync(object? candidate, EvaluationContext cont
 
         while (resolvedValue is JsObject promiseObj && IsPromiseLike(promiseObj))
         {
-            if (promiseObj.TryGetProperty("__promise__", out var internalPromise) &&
+            if (drainMicrotasks &&
+                promiseObj.TryGetProperty("__promise__", out var internalPromise) &&
                 internalPromise is JsPromise promise &&
                 promise.TryGetSettled(out var settled, out var rejected))
             {
@@ -56,7 +65,8 @@ internalPromise is JsPromise promise &&
                 continue;
             }
 
-            if (!promiseObj.TryGetProperty("then", out var thenValue) || thenValue is not IJsCallable thenCallable)
+            if (!promiseObj.TryGetProperty("then", out var thenValue) ||
+                thenValue is not IJsCallable thenCallable)
             {
                 break;
             }
@@ -99,32 +109,33 @@ internalPromise is JsPromise promise &&
             (bool Success, object? Value) awaited;
             try
             {
-                // Drain microtasks until the promise settles
-                var maxIterations = 10000; // Prevent infinite loops
-                var iterations = 0;
-                while (!tcs.Task.IsCompleted && iterations++ < maxIterations)
+                if (drainMicrotasks)
                 {
-                    engine?.DrainMicrotasks();
-
-                    // If still not completed after draining, we have an async promise
-                    // that requires the event loop - this shouldn't happen for proper
-                    // top-level await scenarios
-                    if (!tcs.Task.IsCompleted)
+                    var iterations = 0;
+                    while (!tcs.Task.IsCompleted)
                     {
-                        // Try one more drain in case new microtasks were queued
                         engine?.DrainMicrotasks();
-                    }
-                }
 
-                if (tcs.Task.IsCompleted)
-                {
-                    awaited = tcs.Task.GetAwaiter().GetResult();
-                }
-                else
-                {
-                    throw new InvalidOperationException(
-                        "Promise did not resolve after draining microtasks. This may indicate an infinite promise chain or external async dependency.");
+                        if (tcs.Task.IsCompleted)
+                        {
+                            break;
+                        }
+
+                        if (engine is not null)
+                        {
+                            engine.StartEventLoop();
+                            engine.DrainEventLoopAsync(CancellationToken.None).GetAwaiter().GetResult();
+                            engine.DrainMicrotasks();
+                        }
+
+                        if (++iterations > 10_000)
+                        {
+                            throw new InvalidOperationException(
+                                "Promise did not resolve after draining microtasks and the event loop.");
+                        }
+                    }
                 }
+                awaited = tcs.Task.GetAwaiter().GetResult();
             }
             catch (InvalidOperationException)
             {
@@ -164,7 +175,7 @@ public static bool TryAwaitPromiseOrSchedule(object? candidate, bool asyncStepMo
         // existing blocking semantics.
         if (!asyncStepMode)
         {
-            return TryAwaitPromiseSync(candidate, context, out resolvedValue);
+            return TryAwaitPromiseSync(candidate, context, out resolvedValue, context.DrainAwaitMicrotasks);
         }
 
         // Async-aware mode: if this is a promise-like object, surface it as