fix: lazily create inTransition external source to prevent use-after-dispose

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

@@ -0,0 +1,5 @@
+---
+"solid-js": patch
+---
+
+fix: lazily create inTransition external source to prevent use-after-dispose

packages/solid/src/reactive/signal.ts

@@ -1468,15 +1468,26 @@ function createComputation<Next, Init = unknown>(
   if (IS_DEV && options && options.name) c.name = options.name;
 
   if (ExternalSourceConfig && c.fn) {
+    const sourceFn = c.fn;
     const [track, trigger] = createSignal<void>(undefined, { equals: false });
-    const ordinary = ExternalSourceConfig.factory(c.fn, trigger);
+    const ordinary = ExternalSourceConfig.factory(sourceFn, trigger);
     onCleanup(() => ordinary.dispose());
+    let inTransition: ExternalSource | undefined;
     const triggerInTransition: () => void = () =>
-      startTransition(trigger).then(() => inTransition.dispose());
-    const inTransition = ExternalSourceConfig.factory(c.fn, triggerInTransition);
+      startTransition(trigger).then(() => {
+        if (inTransition) {
+          inTransition.dispose();
+          inTransition = undefined;
+        }
+      });
     c.fn = x => {
       track();
-      return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
+      if (Transition && Transition.running) {
+        if (!inTransition)
+          inTransition = ExternalSourceConfig!.factory(sourceFn, triggerInTransition);
+        return inTransition.track(x);
+      }
+      return ordinary.track(x);
     };
   }
 

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

@@ -1,5 +1,13 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createRoot, createMemo, untrack, enableExternalSource } from "../src/index.js";
+import {
+  createRoot,
+  createMemo,
+  createSignal,
+  untrack,
+  enableExternalSource,
+  startTransition
+} from "../src/index.js";
+import { getSuspenseContext } from "../src/reactive/signal.js";
 
 import "./MessageChannel";
 
@@ -56,7 +64,9 @@ describe("external source", () => {
           }
         },
         dispose: () => {
-          sources.get(trigger)!.forEach(x => x.removeListener(trigger));
+          const trackedSources = sources.get(trigger);
+          if (!trackedSources) return;
+          trackedSources.forEach(x => x.removeListener(trigger));
           sources.delete(trigger);
         }
       };
@@ -87,6 +97,37 @@ describe("external source", () => {
     });
   });
 
+  it("should not throw when rerunning external source in a new transition after disposal", async () => {
+    // Initialize SuspenseContext so startTransition creates a real Transition
+    getSuspenseContext();
+
+    await createRoot(async dispose => {
+      const e = new ExternalSource(0);
+      const [signal, setSignal] = createSignal(0);
+      const memo = createMemo(() => {
+        return e.get() + signal();
+      });
+      expect(memo()).toBe(0);
+
+      // First transition: triggers inTransition creation and subsequent disposal
+      await startTransition(() => {
+        setSignal(1);
+      });
+
+      // Allow the transition-scoped external source to dispose itself.
+      await Promise.resolve();
+
+      // Second transition: should lazily recreate inTransition, not throw on disposed one
+      await expect(
+        startTransition(() => {
+          setSignal(2);
+        })
+      ).resolves.not.toThrow();
+
+      dispose();
+    });
+  });
+
   afterEach(() => {
     vi.resetModules();
   });