fix: re-subscribe external sources after a transition

A computation created during startTransition only tracked the transition-scoped external source. Once that source was disposed, later enableExternalSource updates were lost.

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

Author: ryansolid

.changeset/external-source-transition-subscription.md

@@ -0,0 +1,5 @@
+---
+"solid-js": patch
+---
+
+Re-subscribe `enableExternalSource` computations to the ordinary source after a transition. A computation created while a transition was running only tracked the transition-scoped source; once that source was disposed, later external updates were lost.

packages/solid/src/reactive/signal.ts

@@ -1487,11 +1487,20 @@ function createComputation<Next, Init = unknown>(
     const ordinary = ExternalSourceConfig.factory(sourceFn, trigger);
     onCleanup(() => ordinary.dispose());
     let inTransition: ExternalSource | undefined;
+    let trackedOrdinary = false;
     const triggerInTransition: () => void = () =>
       startTransition(trigger).then(() => {
         if (inTransition) {
           inTransition.dispose();
           inTransition = undefined;
+          // A computation created while a transition was running only ever
+          // tracked the transition-scoped source, so its ordinary source has no
+          // recorded dependencies. Now that the transition is over, re-trigger
+          // once so the computation runs through `ordinary` again and
+          // re-subscribes; otherwise it would never receive further external
+          // updates. If the computation was disposed in the meantime this is a
+          // no-op because it is no longer an observer of `track`.
+          if (!trackedOrdinary) trigger();
         }
       });
     c.fn = x => {
@@ -1501,6 +1510,7 @@ function createComputation<Next, Init = unknown>(
           inTransition = ExternalSourceConfig!.factory(sourceFn, triggerInTransition);
         return inTransition.track(x);
       }
+      trackedOrdinary = true;
       return ordinary.track(x);
     };
   }

packages/solid/test/external-source.spec.ts

@@ -128,6 +128,47 @@ describe("external source", () => {
     });
   });
 
+  it("should keep receiving external updates after being created during a transition", async () => {
+    // Initialize SuspenseContext so startTransition creates a real Transition
+    getSuspenseContext();
+
+    const waitFor = async (fn: () => boolean) => {
+      for (let i = 0; i < 50 && !fn(); i++) {
+        await new Promise(resolve => setTimeout(resolve, 0));
+      }
+    };
+
+    await createRoot(async dispose => {
+      const e = new ExternalSource(0);
+      let memo: (() => number) | undefined;
+
+      // Create the memo while a transition is running. Its first run tracks
+      // dependencies on the transition-scoped external source, never on the
+      // ordinary one.
+      await startTransition(() => {
+        memo = createMemo(() => e.get());
+      });
+      expect(memo!()).toBe(0);
+
+      // First external update is delivered through the transition-scoped source.
+      e.update(1);
+      await waitFor(() => memo!() === 1);
+      expect(memo!()).toBe(1);
+      // Let triggerInTransition's .then() dispose the transition-scoped source
+      // and re-subscribe on the ordinary one.
+      await new Promise(resolve => setTimeout(resolve, 0));
+
+      // Second external update must still be delivered. Before the fix the
+      // transition-scoped source had been disposed and the ordinary source was
+      // never subscribed, so this update was silently lost.
+      e.update(2);
+      await waitFor(() => memo!() === 2);
+      expect(memo!()).toBe(2);
+
+      dispose();
+    });
+  });
+
   afterEach(() => {
     vi.resetModules();
   });