@assistant-ui/core 0.3.13 → 0.3.15

package/src/react/runtimes/useRuntimeAdapters.test.tsx

@@ -0,0 +1,62 @@
+// @vitest-environment jsdom
+
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { useStableRuntimeAdapters } from "./useRuntimeAdapters";
+import type { RuntimeAdapters } from "../../runtimes/remote-thread-list/types";
+import type { ThreadHistoryAdapter } from "../../adapters/thread-history";
+
+const makeHistory = (): ThreadHistoryAdapter => ({
+  load: async () => ({ messages: [] }),
+  append: async () => {},
+});
+
+describe("useStableRuntimeAdapters", () => {
+  it("keeps the previous bag when a fresh literal is shallow-equal", () => {
+    const history = makeHistory();
+    const { result, rerender } = renderHook(
+      ({ adapters }: { adapters: RuntimeAdapters | null }) =>
+        useStableRuntimeAdapters(adapters),
+      { initialProps: { adapters: { history } } },
+    );
+    const first = result.current;
+
+    rerender({ adapters: { history } });
+
+    expect(result.current).toBe(first);
+  });
+
+  it("adopts the new bag when a field changes", () => {
+    const first = makeHistory();
+    const second = makeHistory();
+    const { result, rerender } = renderHook(
+      ({ adapters }: { adapters: RuntimeAdapters | null }) =>
+        useStableRuntimeAdapters(adapters),
+      { initialProps: { adapters: { history: first } } },
+    );
+
+    rerender({ adapters: { history: second } });
+
+    expect(result.current?.history).toBe(second);
+  });
+
+  it("moves between null and a bag", () => {
+    const history = makeHistory();
+    const { result, rerender } = renderHook(
+      ({ adapters }: { adapters: RuntimeAdapters | null }) =>
+        useStableRuntimeAdapters(adapters),
+      { initialProps: { adapters: null as RuntimeAdapters | null } },
+    );
+    expect(result.current).toBeNull();
+
+    rerender({ adapters: { history } });
+    expect(result.current?.history).toBe(history);
+
+    rerender({ adapters: null });
+    expect(result.current).toBeNull();
+
+    rerender({ adapters: {} });
+    expect(result.current).not.toBeNull();
+    expect(result.current).toEqual({});
+  });
+});

package/src/react/runtimes/useRuntimeAdapters.ts

@@ -0,0 +1,28 @@
+import { createContext, useContext } from "react";
+import { useContextProvider } from "@assistant-ui/tap";
+import { useShallowStable } from "@assistant-ui/store/internal";
+import type { RuntimeAdapters } from "../../runtimes/remote-thread-list/types";
+
+const RuntimeAdaptersContext = createContext<RuntimeAdapters | null>(null);
+
+export const useRuntimeAdaptersProvider = <T>(
+  adapters: RuntimeAdapters | null,
+  fn: () => T,
+): T => useContextProvider(RuntimeAdaptersContext, adapters, fn);
+
+export const useRuntimeAdapters = () => {
+  return useContext(RuntimeAdaptersContext);
+};
+
+const NO_ADAPTERS: RuntimeAdapters = {};
+
+// Both adapter faces absorb a fresh but shallow-equal bag from
+// `unstable_useAdapters`, so a per-render literal does not churn the context.
+export const useStableRuntimeAdapters = (
+  adapters: RuntimeAdapters | null | undefined,
+): RuntimeAdapters | null => {
+  const stable = useShallowStable(adapters ?? NO_ADAPTERS);
+  return adapters == null ? null : stable;
+};
+
+export { RuntimeAdaptersContext };

package/src/runtime/api/composer-runtime.ts

@@ -42,6 +42,11 @@ export type {
 };
 
 type BaseComposerState = {
+  /**
+   * Whether the composer can cancel the current run. `true` when the runtime
+   * supports cancel and a run is in flight, not merely when cancel is a
+   * capability.
+   */
   readonly canCancel: boolean;
   readonly canSend: boolean;
   readonly isEditing: boolean;

package/src/runtime/api/thread-list-runtime.ts

@@ -114,6 +114,7 @@ export type ThreadListRuntimeCoreBinding = ThreadListRuntimeCore;
 
 export class ThreadListRuntimeImpl implements ThreadListRuntime {
   private _getState;
+  private _stateBinding: LazyMemoizeSubject<ThreadListState, object>;
   private _core: ThreadListRuntimeCoreBinding;
   private _runtimeFactory: new (
     binding: ThreadRuntimeCoreBinding,
@@ -136,6 +137,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     });
 
     this._getState = stateBinding.getState.bind(stateBinding);
+    this._stateBinding = stateBinding;
 
     this._mainThreadListItemRuntime = new ThreadListItemRuntimeImpl(
       new ShallowMemoizeSubject({
@@ -213,7 +215,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
   }
 
   public subscribe(callback: () => void): Unsubscribe {
-    return this._core.subscribe(callback);
+    return this._stateBinding.subscribe(callback);
   }
 
   private _mainThreadListItemRuntime;

package/src/runtime/api/thread-runtime.ts

@@ -199,7 +199,7 @@ export type ThreadState = {
  * reports it directly; the rest fall back to the trailing assistant message.
  */
 export const getThreadRuntimeCoreIsRunning = (
-  runtime: ThreadRuntimeCore,
+  runtime: Pick<ThreadRuntimeCore, "isRunning" | "messages">,
 ): boolean => {
   if (runtime.isRunning !== undefined) return runtime.isRunning;
   const lastMessage = runtime.messages.at(-1);
@@ -294,6 +294,13 @@ export type ThreadRuntime = {
 
   subscribe(callback: () => void): Unsubscribe;
   cancelRun(): void;
+  /**
+   * Notifies the runtime that the adapter discarded its backing session.
+   * Clears session-scoped tool-invocation state without run-cancel side
+   * effects such as composer draft restoration. Internal API for
+   * external-store adapter authors.
+   */
+  unstable_notifySessionReset(): void;
   getModelContext(): ModelContext;
 
   export(): ExportedMessageRepository;
@@ -339,6 +346,10 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
   private readonly _threadBinding: ThreadRuntimeCoreBinding & {
     getStateState(): ThreadState;
   };
+  private readonly _stateBinding: ShallowMemoizeSubject<
+    ThreadState,
+    ThreadRuntimePath
+  >;
 
   constructor(
     threadBinding: ThreadRuntimeCoreBinding,
@@ -361,6 +372,7 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
       },
     });
 
+    this._stateBinding = stateBinding;
     this._threadBinding = {
       path: threadBinding.path,
       getState: () => threadBinding.getState(),
@@ -392,6 +404,8 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
     this.exportExternalState = this.exportExternalState.bind(this);
     this.startRun = this.startRun.bind(this);
     this.cancelRun = this.cancelRun.bind(this);
+    this.unstable_notifySessionReset =
+      this.unstable_notifySessionReset.bind(this);
     this.stopSpeaking = this.stopSpeaking.bind(this);
     this.connectVoice = this.connectVoice.bind(this);
     this.disconnectVoice = this.disconnectVoice.bind(this);
@@ -435,7 +449,7 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
   }
 
   public subscribe(callback: () => void) {
-    return this._threadBinding.subscribe(callback);
+    return this._stateBinding.subscribe(callback);
   }
 
   public getModelContext() {
@@ -462,6 +476,10 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
     this._threadBinding.getState().cancelRun();
   }
 
+  public unstable_notifySessionReset() {
+    this._threadBinding.getState().unstable_notifySessionReset();
+  }
+
   public stopSpeaking() {
     return this._threadBinding.getState().stopSpeaking();
   }

package/src/runtime/base/base-composer-runtime-core.ts

@@ -240,6 +240,8 @@ export abstract class BaseComposerRuntimeCore
     const originalAttachments = this.attachments;
     const text = this.text;
     const quote = this._quote;
+    const role = this.role;
+    const runConfig = this.runConfig;
     this._quote = undefined;
     this._text = "";
     this._isSending = true;
@@ -291,10 +293,10 @@ export abstract class BaseComposerRuntimeCore
 
     const message: Omit<AppendMessage, "parentId" | "sourceId"> = {
       createdAt: new Date(),
-      role: this.role,
+      role,
       content: text ? [{ type: "text", text }] : [],
       attachments: finalAttachments,
-      runConfig: this.runConfig,
+      runConfig,
       metadata: { custom: { ...(quote ? { quote } : {}) } },
     };
 
@@ -718,9 +720,8 @@ export abstract class BaseComposerRuntimeCore
 
     const session = this._dictationSession;
     const sessionId = this._activeDictationSessionId;
-    session.stop().finally(() => {
-      this._cleanupDictation({ sessionId });
-    });
+    const cleanup = () => this._cleanupDictation({ sessionId });
+    void session.stop().then(cleanup, cleanup);
   }
 
   private _cleanupDictation(options?: { sessionId: number | undefined }): void {

package/src/runtime/base/base-thread-runtime-core.test.ts

@@ -0,0 +1,191 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { RealtimeVoiceAdapter } from "../../adapters/voice";
+import type { AppendMessage } from "../../types/message";
+import type {
+  AddToolResultOptions,
+  ResumeRunConfig,
+  ResumeToolCallOptions,
+  RespondToToolApprovalOptions,
+  RuntimeCapabilities,
+  StartRunConfig,
+  ThreadSuggestion,
+} from "../interfaces/thread-runtime-core";
+import { BaseThreadRuntimeCore } from "./base-thread-runtime-core";
+
+const createVoiceAdapter = () => {
+  let volumeCallback: ((volume: number) => void) | undefined;
+  const session: RealtimeVoiceAdapter.Session = {
+    status: { type: "running" },
+    isMuted: false,
+    disconnect: vi.fn(),
+    mute: vi.fn(),
+    unmute: vi.fn(),
+    onStatusChange: () => () => {},
+    onTranscript: () => () => {},
+    onModeChange: () => () => {},
+    onVolumeChange: (callback) => {
+      volumeCallback = callback;
+      return () => {
+        volumeCallback = undefined;
+      };
+    },
+  };
+
+  return {
+    adapter: { connect: () => session },
+    emitVolume: (volume: number) => volumeCallback?.(volume),
+    session,
+  } satisfies {
+    adapter: RealtimeVoiceAdapter;
+    emitVolume: (volume: number) => void;
+    session: RealtimeVoiceAdapter.Session;
+  };
+};
+
+class TestRuntime extends BaseThreadRuntimeCore {
+  private readonly voiceAdapter: ReturnType<typeof createVoiceAdapter>;
+
+  constructor(voiceAdapter: ReturnType<typeof createVoiceAdapter>) {
+    super({ getModelContext: () => ({}) });
+    this.voiceAdapter = voiceAdapter;
+  }
+
+  get adapters() {
+    return { voice: this.voiceAdapter.adapter };
+  }
+
+  get isDisabled() {
+    return false;
+  }
+
+  get isSendDisabled() {
+    return false;
+  }
+
+  get isLoading() {
+    return false;
+  }
+
+  get suggestions(): readonly ThreadSuggestion[] {
+    return [];
+  }
+
+  get extras() {
+    return undefined;
+  }
+
+  get capabilities(): RuntimeCapabilities {
+    return {
+      switchToBranch: false,
+      switchBranchDuringRun: false,
+      edit: false,
+      delete: false,
+      reload: false,
+      refetchThread: false,
+      cancel: false,
+      unstable_copy: false,
+      speech: false,
+      dictation: false,
+      voice: true,
+      attachments: false,
+      feedback: false,
+      queue: false,
+    };
+  }
+
+  append(_message: AppendMessage) {}
+  deleteMessage(_messageId: string) {}
+  startRun(_config: StartRunConfig) {}
+  resumeRun(_config: ResumeRunConfig) {}
+  addToolResult(_options: AddToolResultOptions) {}
+  resumeToolCall(_options: ResumeToolCallOptions) {}
+  respondToToolApproval(_options: RespondToToolApprovalOptions) {}
+  cancelRun() {}
+  exportExternalState() {
+    return {};
+  }
+  importExternalState(_state: unknown) {}
+  unstable_notifySessionReset() {}
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("BaseThreadRuntimeCore voice volume subscriptions", () => {
+  it("continues notifying subscribers when one throws", () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const voice = createVoiceAdapter();
+    const runtime = new TestRuntime(voice);
+    runtime.connectVoice();
+
+    const listenerError = new Error("listener failed");
+    const laterListener = vi.fn();
+    runtime.subscribeVoiceVolume(() => {
+      throw listenerError;
+    });
+    runtime.subscribeVoiceVolume(laterListener);
+
+    expect(() => voice.emitVolume(0.5)).not.toThrow();
+    expect(laterListener).toHaveBeenCalledOnce();
+    expect(runtime.getVoiceVolume()).toBe(0.5);
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Voice volume listener threw an error",
+      listenerError,
+    );
+  });
+
+  it("continues disconnect cleanup when a subscriber throws", () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const voice = createVoiceAdapter();
+    const runtime = new TestRuntime(voice);
+    runtime.connectVoice();
+
+    const listenerError = new Error("disconnect listener failed");
+    const laterListener = vi.fn();
+    runtime.subscribeVoiceVolume(() => {
+      throw listenerError;
+    });
+    runtime.subscribeVoiceVolume(laterListener);
+
+    expect(() => runtime.disconnectVoice()).not.toThrow();
+    expect(laterListener).toHaveBeenCalledOnce();
+    expect(runtime.getVoiceVolume()).toBe(0);
+    expect(runtime.voice).toBeUndefined();
+    expect(voice.session.disconnect).toHaveBeenCalledOnce();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Voice volume listener threw an error",
+      listenerError,
+    );
+  });
+
+  it("reports rejected subscriber thenables", async () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const voice = createVoiceAdapter();
+    const runtime = new TestRuntime(voice);
+    runtime.connectVoice();
+
+    const listenerError = new Error("async listener failed");
+    const laterListener = vi.fn();
+    runtime.subscribeVoiceVolume(async () => {
+      throw listenerError;
+    });
+    runtime.subscribeVoiceVolume(laterListener);
+
+    voice.emitVolume(0.5);
+
+    await vi.waitFor(() => {
+      expect(laterListener).toHaveBeenCalledOnce();
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] Voice volume listener threw an error",
+        listenerError,
+      );
+    });
+  });
+});

package/src/runtime/base/base-thread-runtime-core.ts

@@ -69,6 +69,7 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   public abstract cancelRun(): void;
   public abstract exportExternalState(): any;
   public abstract importExternalState(state: any): void;
+  public abstract unstable_notifySessionReset(): void;
 
   protected _voiceMessages: ThreadMessage[] = [];
   protected _voiceGeneration = 0;
@@ -355,7 +356,11 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
     unsubs.push(
       session.onVolumeChange((volume) => {
         this._voiceVolume = volume;
-        for (const cb of this._voiceVolumeSubscribers) cb();
+        notifyEventListeners(
+          this._voiceVolumeSubscribers,
+          undefined,
+          "Voice volume",
+        );
       }),
     );
 
@@ -454,7 +459,11 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
     this._voiceSession = undefined;
     this.voice = undefined;
     this._voiceVolume = 0;
-    for (const cb of this._voiceVolumeSubscribers) cb();
+    notifyEventListeners(
+      this._voiceVolumeSubscribers,
+      undefined,
+      "Voice volume",
+    );
     this._voiceMessages = [];
     this._markVoiceMessagesDirty();
     this._notifySubscribers();

package/src/runtime/base/default-thread-composer-runtime-core.ts

@@ -6,6 +6,7 @@ import type {
   ThreadComposerRuntimeCore,
 } from "../interfaces/composer-runtime-core";
 import type { ThreadRuntimeCore } from "../interfaces/thread-runtime-core";
+import { getThreadRuntimeCoreIsRunning } from "../api/thread-runtime";
 import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
 import {
   EMPTY_QUEUE_ITEMS,
@@ -13,13 +14,18 @@ import {
 } from "../../store/scopes/queue-item";
 import { BaseComposerRuntimeCore } from "./base-composer-runtime-core";
 
+const isCancelable = (runtime: Omit<ThreadRuntimeCore, "composer">) => {
+  // capabilities is a subclass field assigned after this composer is constructed
+  if (!runtime.capabilities?.cancel) return false;
+  return getThreadRuntimeCoreIsRunning(runtime);
+};
+
 export class DefaultThreadComposerRuntimeCore
   extends BaseComposerRuntimeCore
   implements ThreadComposerRuntimeCore
 {
-  private _canCancel = false;
   public get canCancel() {
-    return this._canCancel;
+    return isCancelable(this.runtime);
   }
 
   public get canSend() {
@@ -94,12 +100,14 @@ export class DefaultThreadComposerRuntimeCore
   }
 
   public connect() {
+    let lastCanCancel = false;
     let lastIsSendDisabled = this.runtime.isSendDisabled;
     let lastQueue = this.queue;
     return this.runtime.subscribe(() => {
       let changed = false;
-      if (this.canCancel !== this.runtime.capabilities.cancel) {
-        this._canCancel = this.runtime.capabilities.cancel;
+      const nextCanCancel = this.canCancel;
+      if (lastCanCancel !== nextCanCancel) {
+        lastCanCancel = nextCanCancel;
         changed = true;
       }
       if (lastIsSendDisabled !== this.runtime.isSendDisabled) {

package/src/runtime/interfaces/thread-runtime-core.ts

@@ -72,6 +72,11 @@ export type SubmitFeedbackOptions = {
 };
 
 export type ThreadSuggestion = {
+  /** Display heading for the suggestion. Falls back to the prompt when absent. */
+  title?: string;
+  /** Secondary display text shown alongside the title. */
+  label?: string;
+  /** The message text sent when the suggestion is selected. */
   prompt: string;
 };
 
@@ -156,6 +161,7 @@ export type ThreadRuntimeCore = Readonly<{
   startRun: (config: StartRunConfig) => void;
   resumeRun: (config: ResumeRunConfig) => void;
   cancelRun: () => void;
+  unstable_notifySessionReset: () => void;
 
   addToolResult: (options: AddToolResultOptions) => void;
   resumeToolCall: (options: ResumeToolCallOptions) => void;

package/src/runtime/queue/message-queue.ts

@@ -8,6 +8,7 @@ import {
   type QueueItemState,
 } from "../../store/scopes/queue-item";
 import { generateId } from "../../utils/id";
+import { notifyEventListeners } from "../../utils/notify-event-listeners";
 import { getThreadMessageText } from "../../utils/text";
 import type {
   ExternalThreadQueueAdapter,
@@ -87,7 +88,7 @@ export const createMessageQueue = (
   let interrupting = false;
 
   const notify = () => {
-    for (const callback of subscribers) callback();
+    notifyEventListeners(subscribers, undefined, "Message queue");
   };
 
   const setLanes = (next: Record<Lane, readonly QueueItemState[]>) => {

package/src/runtime/utils/message-repository.ts

@@ -81,9 +81,9 @@ type RepositoryMessage = RepositoryParent & {
 const findHead = (
   message: RepositoryMessage | RepositoryParent,
 ): RepositoryMessage | null => {
-  if (message.next) return findHead(message.next);
-  if ("current" in message) return message;
-  return null;
+  let current = message;
+  while (current.next) current = current.next;
+  return "current" in current ? current : null;
 };
 
 class CachedValue<T> {
@@ -116,11 +116,17 @@ export class MessageRepository {
   };
 
   private updateLevels(message: RepositoryMessage, newLevel: number) {
-    message.level = newLevel;
-    for (const childId of message.children) {
-      const childMessage = this.messages.get(childId);
-      if (childMessage) {
-        this.updateLevels(childMessage, newLevel + 1);
+    const pending = [{ message, level: newLevel }];
+
+    while (pending.length > 0) {
+      const current = pending.pop()!;
+      current.message.level = current.level;
+
+      for (const childId of current.message.children) {
+        const childMessage = this.messages.get(childId);
+        if (childMessage) {
+          pending.push({ message: childMessage, level: current.level + 1 });
+        }
       }
     }
   }
@@ -135,7 +141,8 @@ export class MessageRepository {
 
     if (operation === "relink" && parentOrRoot === newParentOrRoot) return;
 
-    if (operation !== "cut") {
+    // `link` receives a fresh ID from `addOrUpdateMessage`; only `relink` can introduce a cycle.
+    if (operation === "relink") {
       for (
         let current: RepositoryMessage | null = newParent;
         current;
@@ -143,7 +150,7 @@ export class MessageRepository {
       ) {
         if (current.current.id === child.current.id) {
           throw new Error(
-            "MessageRepository(performOp/link): A message with the same id already exists in the parent tree. This error occurs if the same message id is found multiple times. This is likely an internal bug in assistant-ui.",
+            "MessageRepository(performOp/relink): A message with the same id already exists in the parent tree. This error occurs if the same message id is found multiple times. This is likely an internal bug in assistant-ui.",
           );
         }
       }
@@ -396,16 +403,17 @@ export class MessageRepository {
     const previousHead = this.head;
 
     if (message.children.length > 0) {
-      const deleteDescendants = (msg: RepositoryMessage) => {
-        for (const childId of msg.children) {
-          const childMessage = this.messages.get(childId);
-          if (childMessage) {
-            deleteDescendants(childMessage);
-            this.messages.delete(childId);
+      const pending = [...message.children];
+      while (pending.length > 0) {
+        const childId = pending.pop()!;
+        const childMessage = this.messages.get(childId);
+        if (childMessage) {
+          for (const descendantId of childMessage.children) {
+            pending.push(descendantId);
           }
+          this.messages.delete(childId);
         }
-      };
-      deleteDescendants(message);
+      }
 
       message.children = [];
       message.next = null;

package/src/runtime/utils/thread-runtime-lifecycle.ts

@@ -0,0 +1,18 @@
+import type { ThreadRuntimeCore } from "../interfaces/thread-runtime-core";
+
+// Invalidation must stay re-entrant: StrictMode's simulated unmount runs the
+// effect cleanup while the runtime object survives into the next mount, so a
+// permanent disposed mark would swallow every later append.
+const generations = new WeakMap<ThreadRuntimeCore, number>();
+
+export const captureThreadRuntimeGeneration = (runtime: ThreadRuntimeCore) =>
+  generations.get(runtime) ?? 0;
+
+export const isThreadRuntimeGenerationCurrent = (
+  runtime: ThreadRuntimeCore,
+  generation: number,
+) => captureThreadRuntimeGeneration(runtime) === generation;
+
+export const invalidateThreadRuntime = (runtime: ThreadRuntimeCore) => {
+  generations.set(runtime, captureThreadRuntimeGeneration(runtime) + 1);
+};

package/src/runtimes/external-store/external-store-shared-options.ts

@@ -14,5 +14,7 @@ export const pickExternalStoreSharedOptions = (
     unstable_capabilities: options.unstable_capabilities,
     suggestions: options.suggestions,
   }) satisfies {
-    [K in keyof Required<ExternalStoreSharedOptions>]: ExternalStoreSharedOptions[K];
+    [
+      K in keyof Required<ExternalStoreSharedOptions>
+    ]: ExternalStoreSharedOptions[K];
   };

package/src/runtimes/external-store/external-store-thread-list-runtime-core.ts

@@ -5,6 +5,8 @@ import type {
   ThreadListRuntimeCore,
 } from "../../runtime/interfaces/thread-list-runtime-core";
 import type { ExternalStoreThreadListAdapter } from "./external-store-adapter";
+import { invalidateThreadRuntime } from "../../runtime/utils/thread-runtime-lifecycle";
+import { notifySubscribers } from "../../subscribable/subscribable";
 
 export type ExternalStoreThreadFactory = () => ExternalStoreThreadRuntimeCore;
 
@@ -150,6 +152,7 @@ export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore
 
     // `initialLoad ||`: `_mainThread!` must be assigned on construction.
     if (initialLoad || previousThreadId !== newThreadId) {
+      if (!initialLoad) invalidateThreadRuntime(this._mainThread);
       this._mainThreadId = newThreadId;
       this._mainThread = this.threadFactory();
     }
@@ -268,6 +271,6 @@ export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore
   }
 
   private _notifySubscribers() {
-    for (const callback of this._subscriptions) callback();
+    notifySubscribers(this._subscriptions);
   }
 }