@assistant-ui/core 0.3.15 → 0.3.17

package/src/react/adapters/LocalStorageThreadListAdapter.tsx

@@ -21,6 +21,7 @@ import type {
   ExportedMessageRepository,
   ExportedMessageRepositoryItem,
 } from "../../internal";
+import { isRecord } from "../../utils/json/is-json";
 import {
   RuntimeAdapterProvider,
   type RuntimeAdapters,
@@ -82,9 +83,6 @@ type StoredSystemMessage = Extract<ThreadMessage, { role: "system" }>;
 type StoredUserMessage = Extract<ThreadMessage, { role: "user" }>;
 type StoredAssistantMessage = Extract<ThreadMessage, { role: "assistant" }>;
 
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
 const parseJSON = (raw: string | null): unknown => {
   if (!raw) return undefined;
   try {

package/src/react/client/InMemoryThreadList.test.tsx

@@ -146,3 +146,52 @@ describe("InMemoryThreadList delete", () => {
     expect(state.mainThreadId).not.toBe("main");
   });
 });
+
+describe("InMemoryThreadList item index selectors", () => {
+  it("resolves index selectors within the archived and regular subsets", async () => {
+    const { getAui } = setup();
+    await act(async () => {});
+
+    await act(async () => {
+      getAui().threads.switchToNewThread();
+    });
+    await act(async () => {});
+    const b = getAui().threads.getState().mainThreadId;
+
+    await act(async () => {
+      getAui().threads.switchToNewThread();
+    });
+    await act(async () => {});
+
+    await act(async () => {
+      getAui().threads.item({ id: b }).archive();
+    });
+    await act(async () => {});
+
+    const state = getAui().threads.getState();
+    expect(state.archivedThreadIds).toEqual([b]);
+    expect(state.threadIds).toHaveLength(2);
+
+    for (const [index, id] of state.archivedThreadIds.entries()) {
+      expect(
+        getAui().threads.item({ index, archived: true }).getState().id,
+      ).toBe(id);
+    }
+    for (const [index, id] of state.threadIds.entries()) {
+      expect(getAui().threads.item({ index }).getState().id).toBe(id);
+      expect(
+        getAui().threads.item({ index, archived: false }).getState().id,
+      ).toBe(id);
+    }
+
+    expect(() =>
+      getAui().threads.item({ index: state.threadIds.length }),
+    ).toThrow("out of bounds");
+    expect(() =>
+      getAui().threads.item({
+        index: state.archivedThreadIds.length,
+        archived: true,
+      }),
+    ).toThrow("out of bounds");
+  });
+});

package/src/react/client/InMemoryThreadList.ts

@@ -236,7 +236,13 @@ const useInMemoryThreadList = (
         const index = threads.findIndex((t) => t.id === selector.id);
         return threadListItems.get({ index });
       }
-      return threadListItems.get(selector);
+      // The lookup is keyed over the combined thread array, while index
+      // selectors address the regular/archived subset the primitives render.
+      const ids = selector.archived ? state.archivedThreadIds : state.threadIds;
+      const id = ids[selector.index];
+      if (id === undefined) return threadListItems.get({ index: -1 });
+      const index = threads.findIndex((t) => t.id === id);
+      return threadListItems.get({ index });
     },
     thread: () => mainThreadClient.methods,
   };

package/src/react/client/Interactables.ts

@@ -24,8 +24,7 @@ import {
   interactableToolName,
 } from "../../model-context/interactable-composer-metadata";
 import { notifySubscribers as notifyStateSubscribers } from "../../subscribable/subscribable";
-
-const PERSISTENCE_DEBOUNCE_MS = 500;
+import { useInteractablePersistenceQueue } from "../interactables-shared/useInteractablePersistenceQueue";
 
 type RestorePersistedStateOptions = {
   stash: Map<string, unknown>;
@@ -109,26 +108,6 @@ const useInteractablesResource = ({
   const adapterRef = useRef<
     Unstable_InteractablePersistenceAdapter | undefined
   >(undefined);
-  const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(
-    undefined,
-  );
-  const syncSeqRef = useRef(0);
-  const latestSyncSeqByIdRef = useRef(new Map<string, number>());
-  const inFlightPersistenceRef = useRef(0);
-  const flushResolversRef = useRef<Array<() => void>>([]);
-  const dirtyIdsRef = useRef(new Set<string>());
-
-  type PersistenceBatch = {
-    adapter: Unstable_InteractablePersistenceAdapter;
-    payload: Unstable_InteractablePersistedState;
-    dirtyIds: Set<string>;
-    seq: number;
-  };
-
-  const outgoingQueueRef = useRef<PersistenceBatch[]>([]);
-  const runPersistenceRef = useRef<(batch?: PersistenceBatch) => void>(
-    () => {},
-  );
 
   const setStateAndRef = useCallback(
     (
@@ -152,149 +131,28 @@ const useInteractablesResource = ({
     return result;
   }, []);
 
-  const takeDirtyBatch = useCallback(
+  const updatePersistenceStatus = useCallback(
     (
-      adapter: Unstable_InteractablePersistenceAdapter,
-    ): PersistenceBatch | undefined => {
-      if (dirtyIdsRef.current.size === 0) return;
-      const dirtyIds = new Set(dirtyIdsRef.current);
-      dirtyIdsRef.current.clear();
-      const seq = ++syncSeqRef.current;
-      for (const id of dirtyIds) latestSyncSeqByIdRef.current.set(id, seq);
-      return { adapter, payload: exportState(), dirtyIds, seq };
-    },
-    [exportState],
-  );
-
-  const enqueuePersistence = useCallback(
-    (adapter: Unstable_InteractablePersistenceAdapter) => {
-      const batch = takeDirtyBatch(adapter);
-      if (!batch) return;
-      if (inFlightPersistenceRef.current === 0) {
-        runPersistenceRef.current(batch);
-      } else {
-        outgoingQueueRef.current.push(batch);
-      }
-    },
-    [takeDirtyBatch],
-  );
-
-  const runPersistence = useCallback(
-    async (batch?: PersistenceBatch) => {
-      const resolved =
-        batch ??
-        (adapterRef.current ? takeDirtyBatch(adapterRef.current) : undefined);
-      if (!resolved) {
-        if (inFlightPersistenceRef.current === 0) {
-          for (const resolve of flushResolversRef.current) resolve();
-          flushResolversRef.current = [];
-        }
-        return;
-      }
-
-      const { adapter, payload, dirtyIds, seq } = resolved;
-      inFlightPersistenceRef.current += 1;
-
-      setStateAndRef((prev) => ({
-        ...prev,
-        persistence: {
-          ...prev.persistence,
-          ...Object.fromEntries(
-            [...dirtyIds].map((id) => [
-              id,
-              { isPending: true, error: undefined },
-            ]),
-          ),
-        },
-      }));
-
-      try {
-        await adapter.save(payload);
-        setStateAndRef((prev) => {
-          let changed = false;
-          const persistence = { ...prev.persistence };
-          for (const id of dirtyIds) {
-            if (
-              latestSyncSeqByIdRef.current.get(id) !== seq ||
-              dirtyIdsRef.current.has(id)
-            )
-              continue;
-            latestSyncSeqByIdRef.current.delete(id);
-            delete persistence[id];
-            changed = true;
-          }
-          return changed ? { ...prev, persistence } : prev;
-        });
-      } catch (e) {
-        setStateAndRef((prev) => {
-          let changed = false;
-          const persistence = { ...prev.persistence };
-          for (const id of dirtyIds) {
-            if (
-              latestSyncSeqByIdRef.current.get(id) !== seq ||
-              dirtyIdsRef.current.has(id)
-            )
-              continue;
-            latestSyncSeqByIdRef.current.delete(id);
-            persistence[id] = { isPending: false, error: e };
-            changed = true;
-          }
-          return changed ? { ...prev, persistence } : prev;
-        });
-      } finally {
-        inFlightPersistenceRef.current -= 1;
-        const next =
-          outgoingQueueRef.current.shift() ??
-          (adapterRef.current && dirtyIdsRef.current.size > 0
-            ? takeDirtyBatch(adapterRef.current)
-            : undefined);
-        if (next) {
-          if (debounceTimerRef.current !== undefined) {
-            clearTimeout(debounceTimerRef.current);
-            debounceTimerRef.current = undefined;
-          }
-          runPersistenceRef.current(next);
-        } else if (inFlightPersistenceRef.current === 0) {
-          for (const resolve of flushResolversRef.current) resolve();
-          flushResolversRef.current = [];
-        }
-      }
+      updater: (
+        prev: Unstable_InteractablesState["persistence"],
+      ) => Unstable_InteractablesState["persistence"],
+    ) => {
+      setStateAndRef((prev) => {
+        const persistence = updater(prev.persistence);
+        return persistence === prev.persistence
+          ? prev
+          : { ...prev, persistence };
+      });
     },
-    [setStateAndRef, takeDirtyBatch],
+    [setStateAndRef],
   );
-  runPersistenceRef.current = (nextBatch) => {
-    void runPersistence(nextBatch);
-  };
 
-  const flushIfPending = useCallback(() => {
-    if (debounceTimerRef.current !== undefined) {
-      clearTimeout(debounceTimerRef.current);
-      debounceTimerRef.current = undefined;
-    }
-    if (adapterRef.current) enqueuePersistence(adapterRef.current);
-  }, [enqueuePersistence]);
-
-  const schedulePersistence = useCallback(
-    (id: string) => {
-      if (!adapterRef.current) return;
-      dirtyIdsRef.current.add(id);
-      if (debounceTimerRef.current !== undefined) {
-        clearTimeout(debounceTimerRef.current);
-      }
-      debounceTimerRef.current = setTimeout(() => {
-        debounceTimerRef.current = undefined;
-        if (inFlightPersistenceRef.current === 0 && adapterRef.current) {
-          enqueuePersistence(adapterRef.current);
-        } else {
-          debounceTimerRef.current = setTimeout(() => {
-            debounceTimerRef.current = undefined;
-            if (adapterRef.current) enqueuePersistence(adapterRef.current);
-          }, PERSISTENCE_DEBOUNCE_MS);
-        }
-      }, PERSISTENCE_DEBOUNCE_MS);
-    },
-    [enqueuePersistence],
-  );
+  const { flushIfPending, schedulePersistence, flush } =
+    useInteractablePersistenceQueue({
+      adapterRef,
+      snapshot: exportState,
+      updatePersistenceStatus,
+    });
 
   const restorePersistedState = useCallback(
     (
@@ -394,23 +252,6 @@ const useInteractablesResource = ({
     };
   }, [persistence, setPersistenceAdapter]);
 
-  const flush = useCallback(async () => {
-    if (debounceTimerRef.current !== undefined) {
-      clearTimeout(debounceTimerRef.current);
-      debounceTimerRef.current = undefined;
-    }
-    const hasWork =
-      inFlightPersistenceRef.current > 0 ||
-      dirtyIdsRef.current.size > 0 ||
-      outgoingQueueRef.current.length > 0;
-    if (!hasWork) return;
-    const p = new Promise<void>((resolve) => {
-      flushResolversRef.current.push(resolve);
-    });
-    if (adapterRef.current) enqueuePersistence(adapterRef.current);
-    return p;
-  }, [enqueuePersistence]);
-
   const setDefState = useCallback(
     (id: string, updater: (prev: unknown) => unknown) => {
       touchedIdsRef.current.add(id);

package/src/react/client/RemoteThreadList.background.test.ts

@@ -0,0 +1,384 @@
+import { useEffect, useState } from "react";
+import { useResource } from "@assistant-ui/tap";
+import { describe, expect, it, vi } from "vitest";
+import { flushTapSync, resource, withKey } from "@assistant-ui/tap";
+import { AuiConfig, createAssistantClient } from "@assistant-ui/store/client";
+import type { ThreadHistoryAdapter } from "../../adapters/thread-history";
+import type { RemoteThreadListAdapter } from "../../runtimes/remote-thread-list/types";
+import { useRuntimeAdapters } from "../runtimes/RuntimeAdapterProvider";
+import { RemoteThreadList } from "./RemoteThreadList";
+
+const stubComposer = { getState: () => ({}) };
+const stubSuggestions = { getState: () => ({ suggestions: [] }) };
+
+type Tracker = {
+  mounts: string[];
+  alive: Set<string>;
+  running: Set<string>;
+  messagesOf?: (id: string) => readonly { status?: { type: string } }[];
+};
+
+const useTrackedThread = (props: { threadId: string; tracker: Tracker }) => {
+  useState(() => {
+    props.tracker.mounts.push(props.threadId);
+    return true;
+  });
+  useEffect(() => {
+    const { tracker, threadId } = props;
+    tracker.alive.add(threadId);
+    return () => {
+      tracker.alive.delete(threadId);
+    };
+    // oxlint-disable-next-line react-hooks/exhaustive-deps -- lifecycle probe tracks the mounted identity
+  }, []);
+  return {
+    getState: () => ({
+      isRunning: props.tracker.running.has(props.threadId),
+      messages: props.tracker.messagesOf?.(props.threadId) ?? [],
+    }),
+    composer: () => stubComposer,
+    suggestions: () => stubSuggestions,
+  };
+};
+const TrackedThread = resource(useTrackedThread);
+
+const useHistoryLoadingThread = (props: {
+  threadId: string;
+  tracker: Tracker;
+  loads: string[];
+}) => {
+  const adapters = useRuntimeAdapters();
+  useState(() => {
+    if (adapters?.history) {
+      props.loads.push(props.threadId);
+      void adapters.history.load();
+    }
+    return true;
+  });
+  return useTrackedThread(props);
+};
+const HistoryLoadingThread = resource(useHistoryLoadingThread);
+
+const makeAdapter = (
+  overrides: Partial<RemoteThreadListAdapter> = {},
+): RemoteThreadListAdapter => ({
+  list: vi.fn(async () => ({ threads: [] })),
+  initialize: vi.fn(async (threadId: string) => ({
+    remoteId: `remote-${threadId}`,
+    externalId: undefined,
+  })),
+  rename: vi.fn(async () => {}),
+  archive: vi.fn(async () => {}),
+  unarchive: vi.fn(async () => {}),
+  delete: vi.fn(async () => {}),
+  generateTitle: vi.fn(
+    async () =>
+      new ReadableStream({
+        start(controller) {
+          controller.close();
+        },
+      }) as never,
+  ),
+  fetch: vi.fn(async (id: string) => ({
+    status: "regular" as const,
+    remoteId: id,
+    externalId: undefined,
+    title: id,
+  })),
+  ...overrides,
+});
+
+const mountBackgroundList = (
+  adapter: RemoteThreadListAdapter,
+  tracker: Tracker,
+) => {
+  const handle = createAssistantClient(
+    AuiConfig({
+      threads: RemoteThreadList({
+        adapter,
+        backgroundThreads: true,
+        thread: (id) =>
+          withKey(id, TrackedThread({ threadId: id, tracker }) as never),
+      }),
+    }),
+  );
+  handle.subscribe(() => {});
+  return handle;
+};
+
+const createTracker = (): Tracker => ({
+  mounts: [],
+  alive: new Set(),
+  running: new Set(),
+});
+
+describe("RemoteThreadList backgroundThreads", () => {
+  it("keeps a switched-away thread mounted with live isRunning", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const tracker = createTracker();
+    const handle = mountBackgroundList(adapter, tracker);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1"]);
+    });
+    const newThreadId = aui.threads.getState().mainThreadId;
+
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+      expect(tracker.mounts).toContain("t1");
+    });
+    const t1MountsAfterFirstVisit = tracker.mounts.filter(
+      (id) => id === "t1",
+    ).length;
+
+    tracker.running.add("t1");
+    flushTapSync(() => aui.threads.switchToThread(newThreadId));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe(newThreadId);
+    });
+
+    expect(tracker.alive.has("t1")).toBe(true);
+    await vi.waitFor(() => {
+      expect(aui.threads.item({ id: "t1" }).getState().isRunning).toBe(true);
+    });
+    expect(aui.threads.item("main").getState().isRunning).toBe(false);
+    expect(tracker.mounts.filter((id) => id === "t1")).toHaveLength(
+      t1MountsAfterFirstVisit,
+    );
+    handle.destroy();
+  });
+
+  it("keeps archived bodies mounted and unmounts on delete and detach", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "regular" as const, remoteId: "t1", title: "One" },
+          { status: "regular" as const, remoteId: "t2", title: "Two" },
+        ],
+      })),
+    });
+    const tracker = createTracker();
+    const handle = mountBackgroundList(adapter, tracker);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1", "t2"]);
+    });
+
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+    flushTapSync(() => aui.threads.switchToThread("t2"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t2");
+    });
+
+    flushTapSync(() => aui.threads.item({ id: "t1" }).archive());
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().archivedThreadIds).toEqual(["t1"]);
+    });
+    expect(tracker.alive.has("t1")).toBe(true);
+
+    flushTapSync(() => aui.threads.item({ id: "t1" }).delete());
+    await vi.waitFor(() => {
+      expect(tracker.alive.has("t1")).toBe(false);
+    });
+
+    flushTapSync(() => aui.threads.item({ id: "t2" }).detach());
+    await vi.waitFor(() => {
+      expect(tracker.alive.has("t2")).toBe(false);
+    });
+    expect(aui.threads.getState().mainThreadId).not.toBe("t2");
+    handle.destroy();
+  });
+
+  it("loads history once per thread body instead of once per switch", async () => {
+    const history: ThreadHistoryAdapter = {
+      load: async () => ({ messages: [] }),
+      append: async () => {},
+    };
+    const useAdapters = () => ({ history });
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+      unstable_useAdapters: useAdapters,
+    });
+    const tracker = createTracker();
+    const loads: string[] = [];
+    const handle = createAssistantClient(
+      AuiConfig({
+        threads: RemoteThreadList({
+          adapter,
+          backgroundThreads: true,
+          thread: (id) =>
+            HistoryLoadingThread({ threadId: id, tracker, loads }) as never,
+        }),
+      }),
+    );
+    handle.subscribe(() => {});
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1"]);
+    });
+    const newThreadId = aui.threads.getState().mainThreadId;
+
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(loads).toContain("t1");
+    });
+    const t1LoadsAfterFirstVisit = loads.filter((id) => id === "t1").length;
+    flushTapSync(() => aui.threads.switchToThread(newThreadId));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe(newThreadId);
+    });
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+
+    expect(loads.filter((id) => id === "t1")).toHaveLength(
+      t1LoadsAfterFirstVisit,
+    );
+    expect(tracker.alive.has("t1")).toBe(true);
+    handle.destroy();
+  });
+
+  it("generates a title once after a new thread initializes, never for loaded threads", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const tracker = createTracker();
+    tracker.messagesOf = () => [{ status: { type: "complete" } }];
+    const handle = mountBackgroundList(adapter, tracker);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1"]);
+    });
+    const newThreadId = aui.threads.getState().mainThreadId;
+
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+    flushTapSync(() => aui.threads.switchToThread(newThreadId));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe(newThreadId);
+    });
+    expect(adapter.generateTitle).not.toHaveBeenCalled();
+
+    await aui.threads.item("main").initialize();
+    await vi.waitFor(() => {
+      expect(adapter.generateTitle).toHaveBeenCalledOnce();
+    });
+    expect(adapter.generateTitle).toHaveBeenCalledWith(
+      `remote-${newThreadId}`,
+      expect.any(Array),
+    );
+
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+    expect(adapter.generateTitle).toHaveBeenCalledOnce();
+    handle.destroy();
+  });
+
+  it("keeps the mode fixed when the prop flips after mount", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const tracker = createTracker();
+    let flip!: () => void;
+    const useFlippingThreads = () => {
+      const [background, setBackground] = useState(true);
+      flip = () => setBackground(false);
+      return useResource(
+        RemoteThreadList({
+          adapter,
+          backgroundThreads: background,
+          thread: (id) =>
+            withKey(id, TrackedThread({ threadId: id, tracker }) as never),
+        }),
+      );
+    };
+    const FlippingThreads = resource(useFlippingThreads);
+    const handle = createAssistantClient(
+      AuiConfig({ threads: FlippingThreads() as never }),
+    );
+    handle.subscribe(() => {});
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1"]);
+    });
+    const newThreadId = aui.threads.getState().mainThreadId;
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+    flushTapSync(() => aui.threads.switchToThread(newThreadId));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe(newThreadId);
+    });
+    expect(tracker.alive.has("t1")).toBe(true);
+
+    flushTapSync(() => flip());
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe(newThreadId);
+    });
+    expect(tracker.alive.has("t1")).toBe(true);
+    handle.destroy();
+  });
+
+  it("keeps one body when a reload remaps a local thread to its remote id", async () => {
+    let listed: { status: "regular"; remoteId: string; title: string }[] = [];
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({ threads: listed })),
+    });
+    const tracker = createTracker();
+    const handle = mountBackgroundList(adapter, tracker);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+
+    await aui.threads.item("main").initialize();
+    const remoteId = `remote-${localId}`;
+    listed = [{ status: "regular" as const, remoteId, title: "One" }];
+    await aui.threads.reload();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toContain(localId);
+    });
+    expect(aui.threads.getState().threadIds).not.toContain(remoteId);
+
+    flushTapSync(() => aui.threads.switchToNewThread());
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).not.toBe(localId);
+    });
+    const localMounts = tracker.mounts.filter((id) => id === localId).length;
+    flushTapSync(() => aui.threads.switchToThread(remoteId));
+    await vi.waitFor(() => {
+      expect(aui.threads.item("main").getState().remoteId).toBe(remoteId);
+    });
+
+    expect(tracker.alive.has(localId)).toBe(true);
+    expect(tracker.alive.has(remoteId)).toBe(false);
+    expect(tracker.mounts.filter((id) => id === localId)).toHaveLength(
+      localMounts,
+    );
+    handle.destroy();
+  });
+});