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

The inTransition external source was eagerly created and disposed after
each transition resolved. When a subsequent transition started, the
disposed source was still referenced, causing errors when .track() was
called on it.

This change makes inTransition lazily initialized on first use during a
transition and properly re-created after disposal. Fixes #2275.

Author: veeceey

packages/solid/src/reactive/signal.ts

@@ -1471,12 +1471,21 @@ function createComputation<Next, Init = unknown>(
     const [track, trigger] = createSignal<void>(undefined, { equals: false });
     const ordinary = ExternalSourceConfig.factory(c.fn, 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(c.fn!, triggerInTransition);
+        return inTransition.track(x);
+      }
+      return ordinary.track(x);
     };
   }
 

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

@@ -1,5 +1,6 @@
 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";
 
@@ -87,6 +88,38 @@ 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);
+      });
+
+      // Wait for transition to complete and inTransition to be disposed
+      await new Promise(r => setTimeout(r, 50));
+
+      // Second transition: should lazily recreate inTransition, not throw on disposed one
+      await expect(
+        startTransition(() => {
+          setSignal(2);
+        })
+      ).resolves.not.toThrow();
+
+      dispose();
+    });
+  });
+
   afterEach(() => {
     vi.resetModules();
   });