fix(signals): await object thenables and surface their sync rejections (closes #2764, #2765)

Introduce a shared object-only `isThenable` (Promises/A+ shape) used by both
the async runtime and `action()`:

- handleAsync now captures a synchronously-rejecting thenable and settles it
  through the same status path an async rejection uses, so the error reaches
  `Errored` instead of leaving the node stuck on the pending path (#2764).
- action() awaits any yielded object thenable, not just `instanceof Promise`,
  matching `await` semantics for custom/cross-realm promises (#2765).

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ryansolid

.changeset/fix-action-thenable-await.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+`action()` now awaits yielded object thenables, not just native `Promise` instances. Yielding a Promise-like object that is not `instanceof Promise` (a custom thenable, cache wrapper, or cross-realm promise) previously resumed the generator immediately with the raw object instead of its settled value. Yield handling now uses an object-thenability check (`typeof value === "object" && typeof value.then === "function"`), shared with the async runtime's thenable detection (#2765).

.changeset/fix-sync-rejecting-thenable.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+Surface synchronously-rejecting thenables. A memo returning a Promise-like thenable that invoked its rejection handler synchronously during `.then()` (e.g. a cache that already knows it failed) had its error dropped and stayed stuck on the pending path forever — `<Loading>` never gave way to `<Errored>`. The thenable branch now captures a synchronous rejection (mirroring the existing sync-resolve handling) and settles it, so the error reaches the boundary the same way an async rejection does (#2764).

packages/solid-signals/src/core/action.ts

@@ -7,6 +7,7 @@ import {
   setActiveTransition,
   type Transition
 } from "./scheduler.js";
+import { isThenable } from "./async.js";
 
 function restoreTransition<T>(transition: Transition, fn: () => T): T {
   globalQueue.initTransition(transition);
@@ -75,14 +76,14 @@ export function action<Args extends any[], Y, R>(
         } catch (e) {
           return done(undefined, e);
         }
-        if (r instanceof Promise)
+        if (isThenable(r))
           return void r.then(run, e => restoreTransition(ctx, () => step(e, true)));
         run(r);
       };
 
       const run = (r: IteratorResult<Y, R>) => {
         if (r.done) return done(r.value);
-        if (r.value instanceof Promise)
+        if (isThenable(r.value))
           return void r.value.then(
             v => restoreTransition(ctx, () => step(v)),
             e => restoreTransition(ctx, () => step(e, true))

packages/solid-signals/src/core/async.ts

@@ -138,21 +138,30 @@ export function settlePendingSource(el: Computed<any>): void {
   if (scheduled) schedule();
 }
 
+// Object-thenable detection (Promises/A+ shape).
+export function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T> {
+  return (
+    value != null &&
+    typeof value === "object" &&
+    typeof (value as { then?: unknown }).then === "function"
+  );
+}
+
 export function handleAsync<T>(
   el: Computed<T>,
   result: T | PromiseLike<T> | AsyncIterable<T>,
   setter?: (value: T) => void
 ): T {
   let iterator: any = false;
-  let isThenable = false;
+  let thenable = false;
   if (typeof result === "object" && result !== null) {
     untrack(() => {
       iterator = (result as any)[Symbol.asyncIterator];
-      isThenable = !iterator && typeof (result as any).then === "function";
+      thenable = !iterator && isThenable(result as T | PromiseLike<T>);
     });
   }
 
-  if (!isThenable && !iterator) {
+  if (!thenable && !iterator) {
     el._inFlight = null;
     return result as T;
   }
@@ -166,7 +175,7 @@ export function handleAsync<T>(
   if (__DEV__ && el._config & CONFIG_SYNC) {
     const message =
       `[SYNC_NODE_RECEIVED_ASYNC] A computed/effect created with \`sync: true\` returned ` +
-      `${isThenable ? "a Promise" : "an AsyncIterable"}. The value would be stored as-is and ` +
+      `${thenable ? "a Promise" : "an AsyncIterable"}. The value would be stored as-is and ` +
       `never awaited in production; remove \`sync: true\` to use async-aware behavior, or ` +
       `unwrap the value before returning.`;
     emitDiagnostic({
@@ -243,8 +252,10 @@ export function handleAsync<T>(
     then?.();
   };
 
-  if (isThenable) {
+  if (thenable) {
     let resolved = false,
+      rejected = false,
+      syncError: any,
       isSync = true;
     (result as PromiseLike<T>).then(
       v => {
@@ -254,11 +265,20 @@ export function handleAsync<T>(
         } else asyncWrite(v);
       },
       e => {
-        if (!isSync) handleError(e);
+        if (isSync) {
+          syncError = e;
+          rejected = true;
+        } else handleError(e);
       }
     );
     isSync = false;
-    if (!resolved) {
+    if (rejected) {
+      // Settle through the same status path an async rejection uses, then
+      // unwind the in-progress synchronous read so the errored node isn't
+      // momentarily read as `undefined`.
+      handleError(syncError);
+      throw syncError;
+    } else if (!resolved) {
       globalQueue.initTransition(resolveTransition(el as any));
       throw new NotReadyError(context!);
     }
@@ -274,9 +294,7 @@ export function handleAsync<T>(
       completed = true;
       try {
         const returned = it.return?.();
-        if (returned && typeof (returned as PromiseLike<IteratorResult<T>>).then === "function") {
-          (returned as PromiseLike<IteratorResult<T>>).then(undefined, () => {});
-        }
+        if (isThenable(returned)) returned.then(undefined, () => {});
       } catch {}
     });
 

packages/solid-signals/tests/action.test.ts

@@ -135,6 +135,30 @@ describe("action", () => {
       expect(receivedValue).toBe(42);
     });
 
+    it("should await a yielded non-Promise thenable and resume with its value (#2765)", async () => {
+      let receivedValue: any;
+
+      // Promise-like, but not `instanceof Promise` (custom thenable / cache
+      // wrapper / cross-realm promise). `await` would wait for this; so must
+      // the action, instead of resuming with the raw object.
+      const thenable = {
+        then(onFulfilled: (v: number) => void) {
+          queueMicrotask(() => onFulfilled(42));
+        }
+      };
+
+      const myAction = action(function* () {
+        receivedValue = yield thenable as any;
+      });
+
+      myAction();
+      expect(receivedValue).toBeUndefined();
+
+      await new Promise(resolve => queueMicrotask(() => resolve(undefined)));
+      await Promise.resolve();
+      expect(receivedValue).toBe(42);
+    });
+
     it("should handle multiple async yields in sequence", async () => {
       const values: number[] = [];
 

packages/solid-signals/tests/syncThenable.test.ts

@@ -1,4 +1,5 @@
 import {
+  createErrorBoundary,
   createMemo,
   createRenderEffect,
   createRoot,
@@ -89,6 +90,35 @@ describe("sync thenable support", () => {
     expect(value()).toBe(undefined);
   });
 
+  it("should surface a synchronously-rejecting thenable to the error boundary (#2764)", () => {
+    // A thenable (e.g. a cache that already knows it failed) that invokes its
+    // rejection handler synchronously during `.then()` must settle the error,
+    // not stay stuck on the pending path.
+    function syncRejectingThenable(reason: unknown): PromiseLike<never> {
+      return {
+        then<R1, R2 = never>(
+          _onfulfilled?: ((v: never) => R1 | PromiseLike<R1>) | null,
+          onrejected?: ((reason: any) => R2 | PromiseLike<R2>) | null
+        ): PromiseLike<R1 | R2> {
+          onrejected?.(reason);
+          return syncThenable(undefined as any);
+        }
+      };
+    }
+
+    const result = createRoot(() =>
+      createErrorBoundary(
+        () => {
+          const value = createMemo(() => syncRejectingThenable(new Error("sync-reject")));
+          return value();
+        },
+        err => `errored: ${(err() as Error).message}`
+      )
+    );
+
+    expect(result()).toBe("errored: sync-reject");
+  });
+
   it("should ignore stale thenable resolution during invalidation cleanup", () => {
     const pending = controlledThenable<number>();
     const [$source, setSource] = createSignal(0);