fix(async): some edge cases

wmertens · wmertens · commit 1d7ae3700d48 · 2026-02-09T18:58:34.000+01:00
diff --git a/packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts b/packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts
@@ -168,7 +168,7 @@ export class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> imple
   override async invalidate() {
     this.$flags$ |= SignalFlags.INVALID;
     this.$clearNextPoll$();
-    if (this.$effects$?.size) {
+    if (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size) {
       // compute in next microtask
       await true;
       this.$computeIfNeeded$();
@@ -265,15 +265,14 @@ export class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> imple
     }
 
     if (isCurrent()) {
-      this.untrackedLoading = false;
-
       clearTimeout(this.$computationTimeoutId$);
 
       if (this.$flags$ & SignalFlags.INVALID) {
         DEBUG && log('Computation finished but signal is invalid, re-running');
         // we became invalid again while running, so we need to re-run the computation to get the new promise
         this.$computeIfNeeded$();
       } else {
+        this.untrackedLoading = false;
         this.$scheduleNextPoll$();
       }
     }
@@ -292,7 +291,10 @@ export class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> imple
   get untrackedValue() {
     this.$computeIfNeeded$();
     if (this.$current$?.$promise$) {
-      if (this.$untrackedValue$ === NEEDS_COMPUTATION) {
+      if (
+        this.$untrackedValue$ === NEEDS_COMPUTATION ||
+        (import.meta.env.TEST ? isServerPlatform() : isServer)
+      ) {
         DEBUG && log('Throwing promise while computing initial value', this);
         throw this.$current$?.$promise$;
       }
diff --git a/packages/qwik/src/core/shared/serdes/inflate.ts b/packages/qwik/src/core/shared/serdes/inflate.ts
@@ -155,6 +155,7 @@ export const inflate = (
         Error,
         unknown?,
         number?,
+        number?,
       ];
       asyncSignal.$computeQrl$ = d[0];
       asyncSignal[_EFFECT_BACK_REF] = d[1];
@@ -172,6 +173,7 @@ export const inflate = (
       }
       // Note, we use the setter so that it schedules polling if needed
       asyncSignal.pollMs = d[7] ?? 0;
+      asyncSignal.$concurrency$ = d[8] ?? 1;
       break;
     }
     // Inflating a SerializerSignal is the same as inflating a ComputedSignal
diff --git a/packages/qwik/src/core/shared/serdes/serdes.unit.ts b/packages/qwik/src/core/shared/serdes/serdes.unit.ts
@@ -699,6 +699,14 @@ describe('shared-serialization', () => {
         ),
         { pollMs: 100 }
       );
+      const concurrent = createAsyncSignal(
+        inlinedQrl(
+          ({ track }) => Promise.resolve(track(() => (foo as SignalImpl).value) + 1),
+          'concurrent',
+          [foo]
+        ),
+        { concurrency: 23 }
+      );
 
       await retryOnPromise(() => {
         // note that this won't subscribe because we're not setting up the context
@@ -707,21 +715,21 @@ describe('shared-serialization', () => {
         expect(always.value).toBe(2);
       });
 
-      const objs = await serialize(dirty, clean, never, always, polling);
+      const objs = await serialize(dirty, clean, never, always, polling, concurrent);
       expect(_dumpState(objs)).toMatchInlineSnapshot(`
         "
         0 AsyncSignal [
-          QRL "6#7#5"
+          QRL "7#8#6"
         ]
         1 AsyncSignal [
-          QRL "6#8#5"
+          QRL "7#9#6"
           Map [
             {string} ":"
             EffectSubscription [
               RootRef 1
               {string} ":"
               Set [
-                RootRef 5
+                RootRef 6
               ]
               Constant null
             ]
@@ -733,28 +741,28 @@ describe('shared-serialization', () => {
           {number} 2
         ]
         2 AsyncSignal [
-          QRL "6#9#5"
+          QRL "7#10#6"
           Map [
             {string} ":"
             EffectSubscription [
               RootRef 2
               {string} ":"
               Set [
-                RootRef 5
+                RootRef 6
               ]
               Constant null
             ]
           ]
         ]
         3 AsyncSignal [
-          QRL "6#10#5"
+          QRL "7#11#6"
           Map [
             {string} ":"
             EffectSubscription [
               RootRef 3
               {string} ":"
               Set [
-                RootRef 5
+                RootRef 6
               ]
               Constant null
             ]
@@ -766,7 +774,7 @@ describe('shared-serialization', () => {
           {number} 2
         ]
         4 AsyncSignal [
-          QRL "6#11#5"
+          QRL "7#12#6"
           Constant undefined
           Constant undefined
           Constant undefined
@@ -775,22 +783,34 @@ describe('shared-serialization', () => {
           Constant NEEDS_COMPUTATION
           {number} 100
         ]
-        5 Signal [
+        5 AsyncSignal [
+          QRL "7#13#6"
+          Constant undefined
+          Constant undefined
+          Constant undefined
+          Constant undefined
+          Constant undefined
+          Constant NEEDS_COMPUTATION
+          Constant undefined
+          {number} 23
+        ]
+        6 Signal [
           {number} 1
-          RootRef 12
-          RootRef 13
           RootRef 14
-        ]
-        6 {string} "mock-chunk"
-        7 {string} "dirty"
-        8 {string} "clean"
-        9 {string} "never"
-        10 {string} "always"
-        11 {string} "polling"
-        12 RootRef "1 1 1"
-        13 RootRef "2 1 1"
-        14 RootRef "3 1 1"
-        (387 chars)"
+          RootRef 15
+          RootRef 16
+        ]
+        7 {string} "mock-chunk"
+        8 {string} "dirty"
+        9 {string} "clean"
+        10 {string} "never"
+        11 {string} "always"
+        12 {string} "polling"
+        13 {string} "concurrent"
+        14 RootRef "1 1 1"
+        15 RootRef "2 1 1"
+        16 RootRef "3 1 1"
+        (452 chars)"
       `);
     });
     it(title(TypeIds.Store), async () => {
diff --git a/packages/qwik/src/core/shared/serdes/serialize.ts b/packages/qwik/src/core/shared/serdes/serialize.ts
@@ -424,7 +424,12 @@ export async function serialize(serializationContext: SerializationContext): Pro
           value.$flags$ & SerializationSignalFlags.SERIALIZATION_STRATEGY_NEVER;
         const isInvalid = value.$flags$ & SignalFlags.INVALID;
         const isSkippable = fastSkipSerialize(value.$untrackedValue$);
-        const pollMs = value instanceof AsyncSignalImpl ? value.$pollMs$ : 0;
+        const pollMs =
+          value instanceof AsyncSignalImpl && value.$pollMs$ > 0 ? value.$pollMs$ : undefined;
+        const concurrency =
+          value instanceof AsyncSignalImpl && value.$concurrency$ !== 1
+            ? value.$concurrency$
+            : undefined;
 
         if (isInvalid || isSkippable) {
           v = NEEDS_COMPUTATION;
@@ -447,10 +452,10 @@ export async function serialize(serializationContext: SerializationContext): Pro
 
         let keepUndefined = false;
 
-        if (v !== NEEDS_COMPUTATION || pollMs) {
+        if (v !== NEEDS_COMPUTATION || pollMs || concurrency !== undefined) {
           out.push(v);
 
-          if (!isAsync && v === undefined) {
+          if (v === undefined) {
             /**
              * If value is undefined, we need to keep it in the output. If we don't do that, later
              * during resuming, the value will be set to symbol(invalid) with flag invalid, and
@@ -459,8 +464,9 @@ export async function serialize(serializationContext: SerializationContext): Pro
             keepUndefined = true;
           }
         }
-        if (pollMs) {
+        if (isAsync) {
           out.push(pollMs);
+          out.push(concurrency);
         }
         output(isAsync ? TypeIds.AsyncSignal : TypeIds.ComputedSignal, out, keepUndefined);
       } else {
diff --git a/packages/qwik/src/core/tests/use-async.spec.tsx b/packages/qwik/src/core/tests/use-async.spec.tsx
@@ -10,6 +10,7 @@ import {
   useErrorBoundary,
   useSignal,
   useTask$,
+  type AsyncSignal,
 } from '@qwik.dev/core';
 import { domRender, ssrRenderToDom, trigger, waitForDrain } from '@qwik.dev/core/testing';
 import { describe, expect, it } from 'vitest';
@@ -303,6 +304,22 @@ describe.each([
         </>
       );
     });
+    it('should not show initial value after SSR', async () => {
+      const ref = {} as { s: AsyncSignal<number> };
+      const Cmp = component$(() => {
+        const asyncValue = useAsync$(async () => 42, { initial: 10 });
+        ref.s = asyncValue;
+        return <div>{asyncValue.value}</div>;
+      });
+      const { vNode } = await render(<Cmp />, { debug });
+      expect(vNode).toMatchVDOM(
+        <>
+          <div>
+            <Signal>{'42'}</Signal>
+          </div>
+        </>
+      );
+    });
   });
 
   describe('error', () => {
