fix(signals): report isPending during refresh()/refetch of a resting optimistic source (closes #2799)

A resting `createOptimistic(asyncFn)` (no active override, `_overrideValue ===
NOT_PENDING`) reported `isPending` as `false` while a `refresh()`-driven refetch
was in flight, diverging from `createMemo` and `createOptimisticStore` which both
report `true`. The optimistic-capable identity was wrongly muting pendingness even
when no override was active.

`computePendingState` now excludes only a resting optimistic node from the
upstream "value held in transition" check (that held `_pendingValue` belongs to a
reverting optimistic write, not a refetch). A resting optimistic node otherwise
behaves like a plain async memo, reporting pending via the downstream
async-in-flight check. Muting pending remains the job of an active override.

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

Author: ryansolid

.changeset/fix-ispending-optimistic-refresh.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+Fix `isPending` not reporting pending during a `refresh()`/refetch of an async `createOptimistic` accessor (#2799). A resting optimistic node (no active override) now reports pending exactly like a plain async memo while a refetch is in flight with stale data; muting pending remains the job of an active optimistic override only.

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

@@ -1118,11 +1118,18 @@ function computePendingState(el: Signal<any> | Computed<any>): boolean {
     }
     return true;
   }
-  if (el._overrideValue !== undefined && el._overrideValue === NOT_PENDING && !el._parentSource) {
-    return false;
-  }
-  // Upstream: value held in transition (not during initial load)
-  if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
+  // Upstream: value held in transition (not during initial load). Excluded for a
+  // *resting* optimistic node (`_overrideValue === NOT_PENDING`, no active override):
+  // its held `_pendingValue` belongs to a reverting optimistic write, not a refetch, so
+  // it must not read as pending. Muting pending is the job of an active override; a
+  // resting optimistic node otherwise behaves like a plain async memo and reports
+  // pending only via the downstream async-in-flight check below (#2799).
+  if (
+    el._overrideValue !== NOT_PENDING &&
+    el._pendingValue !== NOT_PENDING &&
+    !(comp._statusFlags & STATUS_UNINITIALIZED)
+  )
+    return true;
   // Downstream: async in flight with previous value (not initial load)
   // STATUS_UNINITIALIZED is cleared on first successful completion
   return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));

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

@@ -905,6 +905,40 @@ describe("createOptimistic", () => {
       expect(isPending($data!)).toBe(false);
     });
 
+    it("isPending reports pending while refresh() refetches an async optimistic accessor (#2799)", async () => {
+      let resolveFetch: ((v: number[]) => void) | null = null;
+      const makeFetch = () => new Promise<number[]>(r => (resolveFetch = r));
+
+      let $data!: SourceAccessor<number[]>;
+      createRoot(() => {
+        const [data] = createOptimistic<number[]>(() => makeFetch());
+        $data = data;
+        // Keep the node alive / recomputing on refresh.
+        createRenderEffect(data, () => {});
+      });
+
+      // Initial load — isPending stays false for the first load (no stale data).
+      flush();
+      resolveFetch!([1, 2, 3]);
+      await Promise.resolve();
+      flush();
+      expect($data()).toEqual([1, 2, 3]);
+      expect(isPending(() => $data())).toBe(false);
+
+      // refresh() forces a refetch; the resolved value is still visible while the
+      // new fetch is in flight, so isPending must report true (same as an async memo).
+      refresh($data);
+      flush();
+      expect(isPending(() => $data())).toBe(true);
+
+      // Settling the refetch clears pending.
+      resolveFetch!([4, 5, 6]);
+      await Promise.resolve();
+      flush();
+      expect($data()).toEqual([4, 5, 6]);
+      expect(isPending(() => $data())).toBe(false);
+    });
+
     it("plain optimistic stays true through refresh-of-unrelated-async (issue #2685)", async () => {
       // github.com/solidjs/solid/issues/2685 — the optimistic signal itself
       // is plain (no async source); the async work comes from refresh()ing