@assistant-ui/react 0.15.30 → 0.15.32

package/src/primitives/composer/ComposerInput.text-change.test.tsx

@@ -0,0 +1,68 @@
+// @vitest-environment jsdom
+
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+} from "@testing-library/react";
+import type { FC } from "react";
+import { afterEach, expect, it } from "vitest";
+import { useAui } from "@assistant-ui/store";
+import { useLocalRuntime } from "@assistant-ui/core/react";
+import type { ChatModelAdapter } from "@assistant-ui/core";
+import { AssistantRuntimeProvider } from "../../context";
+import { ThreadPrimitiveViewportProvider } from "../../context/providers/ThreadViewportProvider";
+import { ComposerPrimitiveInput } from "./ComposerInput";
+
+const adapter: ChatModelAdapter = {
+  async *run() {
+    yield { content: [{ type: "text", text: "done" }] };
+  },
+};
+
+afterEach(cleanup);
+
+it("emits composer.textChange with the user origin for typing and the send origin for the clear", async () => {
+  let aui!: ReturnType<typeof useAui>;
+  const Capture: FC = () => {
+    aui = useAui();
+    return null;
+  };
+  const App: FC = () => (
+    <AssistantRuntimeProvider runtime={useLocalRuntime(adapter)}>
+      <Capture />
+      <ThreadPrimitiveViewportProvider>
+        <ComposerPrimitiveInput aria-label="Composer" />
+      </ThreadPrimitiveViewportProvider>
+    </AssistantRuntimeProvider>
+  );
+  render(<App />);
+  const changes: unknown[] = [];
+  aui.on({ scope: "*", event: "composer.textChange" }, (change) =>
+    changes.push(change),
+  );
+  const input = screen.getByRole("textbox", { name: "Composer" });
+
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "hi" } });
+  });
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "" } });
+  });
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "hello" } });
+  });
+  await act(async () => {
+    aui.composer().send();
+  });
+
+  const threadId = aui.threads().getState().mainThreadId;
+  expect(changes).toEqual([
+    { threadId, text: "hi", origin: "user" },
+    { threadId, text: "", origin: "user" },
+    { threadId, text: "hello", origin: "user" },
+    { threadId, text: "", origin: "send" },
+  ]);
+});

package/src/primitives/composer/ComposerInput.thread-scope.test.tsx

@@ -0,0 +1,82 @@
+// @vitest-environment jsdom
+
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import { afterEach, expect, it } from "vitest";
+import { AuiConfig, AuiProvider, Derived, useAui } from "@assistant-ui/store";
+import { ExternalThread, InMemoryThreadList } from "@assistant-ui/core/store";
+import { resource, useResource } from "@assistant-ui/tap";
+import { ThreadPrimitiveViewportProvider } from "../../context/providers/ThreadViewportProvider";
+import { ComposerPrimitiveInput } from "./ComposerInput";
+
+const StandaloneThread = resource(function useStandaloneThread() {
+  return useResource(ExternalThread({ messages: [] }));
+});
+const StandaloneApp = () => {
+  const config = AuiConfig({
+    thread: StandaloneThread(),
+    composer: Derived({
+      source: "thread",
+      query: {},
+      get: (aui) => aui.thread.composer(),
+    }),
+  });
+  return (
+    <AuiProvider config={config}>
+      <ThreadPrimitiveViewportProvider>
+        <ComposerPrimitiveInput aria-label="Composer" />
+      </ThreadPrimitiveViewportProvider>
+    </AuiProvider>
+  );
+};
+
+afterEach(cleanup);
+
+it("edits a draft without a thread-list scope", async () => {
+  render(<StandaloneApp />);
+  const input = screen.getByRole("textbox", {
+    name: "Composer",
+  }) as HTMLTextAreaElement;
+  await act(async () => {
+    fireEvent.change(input, { target: { value: "New question" } });
+  });
+  expect(input.value).toBe("New question");
+});
+
+it("restores composer focus when the thread switches", async () => {
+  let captured!: ReturnType<typeof useAui>;
+  const App = () => {
+    const aui = useAui({
+      threads: InMemoryThreadList({
+        thread: () => ExternalThread({ messages: [] }),
+      }),
+    });
+    captured = aui;
+    return (
+      <AuiProvider value={aui}>
+        <ThreadPrimitiveViewportProvider>
+          <button>Outside</button>
+          <ComposerPrimitiveInput aria-label="Composer" autoFocus />
+        </ThreadPrimitiveViewportProvider>
+      </AuiProvider>
+    );
+  };
+  render(<App />);
+  const input = screen.getByRole("textbox", { name: "Composer" });
+  expect(document.activeElement).toBe(input);
+  act(() => screen.getByRole("button", { name: "Outside" }).focus());
+  const oldId = captured.threads.getState().mainThreadId;
+  await act(async () => {
+    captured.threads.switchToNewThread();
+  });
+  await waitFor(() =>
+    expect(captured.threads.getState().mainThreadId).not.toBe(oldId),
+  );
+  expect(document.activeElement).toBe(input);
+});

package/src/primitives/composer/ComposerInput.tsx

@@ -393,7 +393,8 @@ export const ComposerPrimitiveInput = forwardRef<
     useEffect(() => {
       if (
         aui.composer.getState().type !== "thread" ||
-        !unstable_focusOnThreadSwitched
+        !unstable_focusOnThreadSwitched ||
+        !aui.optional.threads
       )
         return undefined;
 
@@ -426,7 +427,7 @@ export const ComposerPrimitiveInput = forwardRef<
           const isComposing = nativeIsComposing || compositionRef.current;
           // Standalone tap roots need a synchronous flush while the input is composing.
           flushTapSync(() => {
-            aui.composer.setText(e.target.value);
+            aui.composer.setText(e.target.value, { origin: "user" });
           });
           if (isComposing) return;
           const pos = e.target.selectionStart ?? e.target.value.length;
@@ -453,7 +454,7 @@ export const ComposerPrimitiveInput = forwardRef<
           if (!aui.composer.getState().isEditing) return;
           const target = e.target as HTMLTextAreaElement;
           flushTapSync(() => {
-            aui.composer.setText(target.value);
+            aui.composer.setText(target.value, { origin: "user" });
           });
           const pos = target.selectionStart ?? target.value.length;
           if (pluginRegistry) {

package/src/primitives/composer/trigger/triggerSelectionResource.test.ts

@@ -77,7 +77,7 @@ describe("TriggerSelectionResource", () => {
 
     root.getValue().selectItem(item);
 
-    expect(setText).toHaveBeenCalledWith("@file.txt tail");
+    expect(setText).toHaveBeenCalledWith("@file.txt tail", { origin: "user" });
     expect(setCursorPosition).toHaveBeenCalledWith("@file.txt".length + 1);
     expect(onSelected).toHaveBeenCalledOnce();
   });
@@ -120,7 +120,7 @@ describe("TriggerSelectionResource", () => {
 
     root.getValue().selectItem(item);
 
-    expect(setText).toHaveBeenCalledWith("before tail");
+    expect(setText).toHaveBeenCalledWith("before tail", { origin: "user" });
     expect(setCursorPosition).toHaveBeenCalledWith(7);
   });
 
@@ -153,7 +153,7 @@ describe("TriggerSelectionResource", () => {
     root.getValue().selectItem(item);
 
     expect(setText).toHaveBeenCalledOnce();
-    expect(setText).toHaveBeenCalledWith("@file.txt ");
+    expect(setText).toHaveBeenCalledWith("@file.txt ", { origin: "user" });
     expect(textRef.value).toBe("@file.txt ");
   });
 
@@ -166,6 +166,8 @@ describe("TriggerSelectionResource", () => {
 
     root.getValue().selectItem(item);
 
-    expect(setText).toHaveBeenCalledWith("hello @file.txt tail");
+    expect(setText).toHaveBeenCalledWith("hello @file.txt tail", {
+      origin: "user",
+    });
   });
 });

package/src/primitives/composer/trigger/triggerSelectionResource.ts

@@ -90,6 +90,7 @@ const useTriggerSelectionResource = ({
       const directive = behavior.formatter.serialize(item);
       aui.composer.setText(
         before + directive + (after.startsWith(" ") ? after : ` ${after}`),
+        { origin: "user" },
       );
       setCursorPosition(before.length + directive.length + 1);
     };
@@ -101,6 +102,7 @@ const useTriggerSelectionResource = ({
       if (behavior.removeOnExecute) {
         aui.composer.setText(
           before + (after.startsWith(" ") ? after.slice(1) : after),
+          { origin: "user" },
         );
         setCursorPosition(before.length);
       } else {

package/src/primitives/reasoning/useScrollLock.test.tsx

@@ -31,9 +31,29 @@ function stubWidths(
 function lockWithin(container: HTMLElement) {
   const animated = document.createElement("div");
   container.appendChild(animated);
+  return createLock(animated).lock;
+}
+
+function createLock(animated: HTMLElement) {
   const ref = { current: animated };
-  const { result } = renderHook(() => useScrollLock(ref, 200));
-  return result.current;
+  const { result, unmount } = renderHook(() => useScrollLock(ref, 200));
+  return { lock: result.current, dispose: unmount };
+}
+
+function createSharedScroller() {
+  const scroller = document.createElement("div");
+  scroller.style.overflowY = "auto";
+  scroller.style.borderWidth = "0px";
+  scroller.style.paddingRight = "4px";
+  document.body.appendChild(scroller);
+  Object.defineProperty(scroller, "offsetWidth", { value: 306 });
+  Object.defineProperty(scroller, "clientWidth", {
+    get: () => (scroller.style.scrollbarWidth === "none" ? 306 : 300),
+  });
+  const first = document.createElement("div");
+  const second = document.createElement("div");
+  scroller.append(first, second);
+  return { scroller, first: createLock(first), second: createLock(second) };
 }
 
 describe("useScrollLock", () => {
@@ -115,6 +135,55 @@ describe("useScrollLock", () => {
     expect(scroller.style.scrollbarWidth).toBe("");
   });
 
+  it("keeps overlapping animations locked until the last one finishes", () => {
+    vi.useFakeTimers();
+    const { scroller, first, second } = createSharedScroller();
+    scroller.scrollTop = 120;
+
+    first.lock();
+    vi.advanceTimersByTime(100);
+    second.lock();
+    expect(scroller.style.paddingRight).toBe("10px");
+
+    vi.advanceTimersByTime(100);
+    expect(scroller.style.scrollbarWidth).toBe("none");
+    expect(scroller.style.paddingRight).toBe("10px");
+    scroller.scrollTop = 90;
+    scroller.dispatchEvent(new Event("scroll"));
+    expect(scroller.scrollTop).toBe(120);
+
+    vi.advanceTimersByTime(100);
+    expect(scroller.style.scrollbarWidth).toBe("");
+    expect(scroller.style.paddingRight).toBe("4px");
+    scroller.scrollTop = 90;
+    scroller.dispatchEvent(new Event("scroll"));
+    expect(scroller.scrollTop).toBe(90);
+  });
+
+  it.each(["first", "second"] as const)(
+    "preserves a restarted shared lock when the %s owner is disposed first",
+    (disposedFirst) => {
+      vi.useFakeTimers();
+      const shared = createSharedScroller();
+      const { scroller, first, second } = shared;
+      first.lock();
+      second.lock();
+      vi.advanceTimersByTime(100);
+      first.lock();
+
+      shared[disposedFirst].dispose();
+      expect(scroller.style.scrollbarWidth).toBe("none");
+      expect(scroller.style.paddingRight).toBe("10px");
+
+      shared[disposedFirst === "first" ? "second" : "first"].dispose();
+      expect(scroller.style.scrollbarWidth).toBe("");
+      expect(scroller.style.paddingRight).toBe("4px");
+      scroller.style.scrollbarWidth = "thin";
+      vi.advanceTimersByTime(200);
+      expect(scroller.style.scrollbarWidth).toBe("thin");
+    },
+  );
+
   it("leaves the padding alone when no scrollbar takes space", () => {
     const scroller = document.createElement("div");
     scroller.style.overflowY = "auto";

package/src/primitives/reasoning/useScrollLock.ts

@@ -12,6 +12,74 @@ const findScrollableAncestor = (element: HTMLElement | null) => {
   return null;
 };
 
+const scrollLocks = new WeakMap<
+  HTMLElement,
+  { count: number; restore: () => void }
+>();
+
+const acquireScrollLock = (scrollContainer: HTMLElement) => {
+  const existing = scrollLocks.get(scrollContainer);
+  if (existing) {
+    existing.count++;
+    return existing;
+  }
+
+  const scrollPosition = scrollContainer.scrollTop;
+  const scrollbarWidth = scrollContainer.style.scrollbarWidth;
+
+  // Hiding the scrollbar collapses its gutter on classic scrollbars, which
+  // shifts centered content horizontally; compensate with padding on the
+  // side the scrollbar occupies (the left side in RTL).
+  const computed = getComputedStyle(scrollContainer);
+  const paddingSide =
+    computed.direction === "rtl" ? "paddingLeft" : "paddingRight";
+  const previousPadding = scrollContainer.style[paddingSide];
+  const elementScrollbarSize =
+    scrollContainer.offsetWidth -
+    scrollContainer.clientWidth -
+    parseFloat(computed.borderLeftWidth) -
+    parseFloat(computed.borderRightWidth);
+  // A root element's offsetWidth already excludes the viewport scrollbar, so
+  // the element formula reports zero once the scroll propagates to the
+  // viewport, and only then does the viewport measure apply. A body that
+  // scrolls in its own right is measured by the element formula like any
+  // other scroller, whether or not the viewport is scrolling too.
+  const ownerDocument = scrollContainer.ownerDocument;
+  const isRootScroller =
+    scrollContainer === ownerDocument.documentElement ||
+    scrollContainer === ownerDocument.body;
+  const scrollbarSize =
+    isRootScroller && elementScrollbarSize <= 0
+      ? (ownerDocument.defaultView?.innerWidth ?? 0) -
+        ownerDocument.documentElement.clientWidth
+      : elementScrollbarSize;
+
+  scrollContainer.style.scrollbarWidth = "none";
+  if (scrollbarSize > 0) {
+    scrollContainer.style[paddingSide] = `${
+      parseFloat(computed[paddingSide]) + scrollbarSize
+    }px`;
+  }
+
+  const restoreStyles = () => {
+    scrollContainer.style.scrollbarWidth = scrollbarWidth;
+    scrollContainer.style[paddingSide] = previousPadding;
+  };
+
+  const resetPosition = () => (scrollContainer.scrollTop = scrollPosition);
+  scrollContainer.addEventListener("scroll", resetPosition);
+
+  const lock = {
+    count: 1,
+    restore: () => {
+      scrollContainer.removeEventListener("scroll", resetPosition);
+      restoreStyles();
+    },
+  };
+  scrollLocks.set(scrollContainer, lock);
+  return lock;
+};
+
 /**
  * Locks scroll position during collapsible/height animations and hides scrollbar.
  *
@@ -59,61 +127,20 @@ export const useScrollLock = <T extends HTMLElement = HTMLElement>(
       return;
     }
 
-    const scrollPosition = scrollContainer.scrollTop;
-    const scrollbarWidth = scrollContainer.style.scrollbarWidth;
-
-    // Hiding the scrollbar collapses its gutter on classic scrollbars, which
-    // shifts centered content horizontally; compensate with padding on the
-    // side the scrollbar occupies (the left side in RTL).
-    const computed = getComputedStyle(scrollContainer);
-    const paddingSide =
-      computed.direction === "rtl" ? "paddingLeft" : "paddingRight";
-    const previousPadding = scrollContainer.style[paddingSide];
-    const elementScrollbarSize =
-      scrollContainer.offsetWidth -
-      scrollContainer.clientWidth -
-      parseFloat(computed.borderLeftWidth) -
-      parseFloat(computed.borderRightWidth);
-    // A root element's offsetWidth already excludes the viewport scrollbar, so
-    // the element formula reports zero once the scroll propagates to the
-    // viewport, and only then does the viewport measure apply. A body that
-    // scrolls in its own right is measured by the element formula like any
-    // other scroller, whether or not the viewport is scrolling too.
-    const ownerDocument = scrollContainer.ownerDocument;
-    const isRootScroller =
-      scrollContainer === ownerDocument.documentElement ||
-      scrollContainer === ownerDocument.body;
-    const scrollbarSize =
-      isRootScroller && elementScrollbarSize <= 0
-        ? (ownerDocument.defaultView?.innerWidth ?? 0) -
-          ownerDocument.documentElement.clientWidth
-        : elementScrollbarSize;
-
-    scrollContainer.style.scrollbarWidth = "none";
-    if (scrollbarSize > 0) {
-      scrollContainer.style[paddingSide] = `${
-        parseFloat(computed[paddingSide]) + scrollbarSize
-      }px`;
-    }
-
-    const restoreStyles = () => {
-      scrollContainer.style.scrollbarWidth = scrollbarWidth;
-      scrollContainer.style[paddingSide] = previousPadding;
-    };
+    const lock = acquireScrollLock(scrollContainer);
 
-    const resetPosition = () => (scrollContainer.scrollTop = scrollPosition);
-    scrollContainer.addEventListener("scroll", resetPosition);
-
-    const timeoutId = setTimeout(() => {
-      scrollContainer.removeEventListener("scroll", resetPosition);
-      restoreStyles();
-      cleanupRef.current = null;
-    }, animationDuration);
+    const timeoutId = setTimeout(
+      () => cleanupRef.current?.(),
+      animationDuration,
+    );
 
     cleanupRef.current = () => {
       clearTimeout(timeoutId);
-      scrollContainer.removeEventListener("scroll", resetPosition);
-      restoreStyles();
+      if (--lock.count === 0) {
+        lock.restore();
+        scrollLocks.delete(scrollContainer);
+      }
+      cleanupRef.current = null;
     };
   }, [animationDuration, animatedElementRef]);
 

package/src/primitives/thread/ThreadRoot.test.tsx

@@ -4,7 +4,7 @@ import { act, render, screen, waitFor } from "@testing-library/react";
 import type { FC, PropsWithChildren } from "react";
 import { describe, expect, it, vi } from "vitest";
 import { AssistantRuntimeProvider } from "../../context";
-import { useLocalRuntime } from "../../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import type {
   ChatModelAdapter,
   SpeechSynthesisAdapter,

package/src/primitives/thread/ThreadViewport.thread-scope.test.tsx

@@ -0,0 +1,51 @@
+// @vitest-environment jsdom
+
+import { cleanup, render } from "@testing-library/react";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { AuiConfig, AuiProvider } from "@assistant-ui/store";
+import { resource, useResource } from "@assistant-ui/tap";
+import { ExternalThread } from "@assistant-ui/core/store";
+import { ThreadPrimitiveViewport } from "./ThreadViewport";
+
+const StandaloneThread = resource(function useStandaloneThread() {
+  return useResource(ExternalThread({ messages: [] }));
+});
+
+const Harness = ({ standalone }: { standalone: boolean }) => {
+  const config = AuiConfig({
+    thread: standalone ? StandaloneThread() : ExternalThread({ messages: [] }),
+  });
+  return (
+    <AuiProvider config={config}>
+      <ThreadPrimitiveViewport role="region" aria-label="Conversation">
+        Conversation content
+      </ThreadPrimitiveViewport>
+    </AuiProvider>
+  );
+};
+
+beforeEach(() => {
+  vi.stubGlobal(
+    "ResizeObserver",
+    class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    },
+  );
+});
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+});
+
+it.each([true, false])(
+  "renders a thread viewport with standalone=%s",
+  (standalone) => {
+    const view = render(<Harness standalone={standalone} />);
+    expect(view.getByRole("region", { name: "Conversation" }).textContent).toBe(
+      "Conversation content",
+    );
+  },
+);

package/src/primitives/thread/useThreadViewportAutoScroll.ts

@@ -2,6 +2,7 @@
 
 import {
   useCallback,
+  useEffect,
   useInsertionEffect,
   useRef,
   type RefCallback,
@@ -56,7 +57,7 @@ export const useThreadViewportAutoScroll = <TElement extends HTMLElement>({
   const divRef = useRef<TElement>(null);
   const hasMessages = useAuiState((s) => s.thread.messages.length > 0);
   const firstMessageId = useAuiState((s) => s.thread.messages[0]?.id);
-  const threadId = useAuiState((s) => s.threadListItem.id);
+  const threadId = useAuiState((s) => s.optional.threadListItem?.id);
   const isRunning = useAuiState((s) => s.thread.isRunning);
   const threadViewportStore = useThreadViewportStore();
   const binding = getThreadViewportAutoScroll(threadViewportStore);
@@ -105,7 +106,12 @@ export const useThreadViewportAutoScroll = <TElement extends HTMLElement>({
 
   useOnScrollToBottom(({ behavior }) => controller.scrollToBottom(behavior));
   useAuiEvent("thread.runStart", () => controller.runStarted());
-  useAuiEvent("threads.selectionChanged", () => controller.threadSwitched());
+  useEffect(() => {
+    if (!aui.optional.threads) return;
+    return aui.on("threads.selectionChanged", () =>
+      controller.threadSwitched(),
+    );
+  }, [aui, controller]);
 
   return useManagedRef(
     useCallback(

package/src/primitives/threadListItem/ThreadListItemRoot.tsx

@@ -51,7 +51,10 @@ export const ThreadListItemPrimitiveRoot = forwardRef<
       if (event.key === "ArrowDown" || event.key === "ArrowUp") {
         const triggers = getItems()
           .map((item) => item.ref.current)
-          .filter((node): node is HTMLButtonElement => node !== null);
+          .filter(
+            (node): node is HTMLButtonElement =>
+              node !== null && !node.disabled,
+          );
         const next =
           triggers[
             triggers.indexOf(trigger) + (event.key === "ArrowDown" ? 1 : -1)

package/src/primitives/threadListItem/ThreadListItemUnarchive.test.tsx

@@ -0,0 +1,52 @@
+// @vitest-environment jsdom
+
+import { cleanup, fireEvent, render } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  AssistantRuntimeProvider,
+  ThreadListItemByIndexProvider,
+} from "@assistant-ui/core/react";
+import {
+  AssistantRuntimeImpl,
+  ExternalStoreRuntimeCore,
+} from "@assistant-ui/core/internal";
+import { ThreadListItemPrimitiveUnarchive } from "./ThreadListItemUnarchive";
+
+afterEach(cleanup);
+
+describe("ThreadListItemPrimitive.Unarchive", () => {
+  it.each([true, false])(
+    "renders an actionable button only when unarchive is supported (%s)",
+    (supported) => {
+      const onUnarchive = vi.fn();
+      const runtime = new AssistantRuntimeImpl(
+        new ExternalStoreRuntimeCore({
+          messages: [],
+          onNew: async () => {},
+          adapters: {
+            threadList: {
+              archivedThreads: [{ id: "archived", status: "archived" }],
+              onUnarchive: supported ? onUnarchive : undefined,
+            },
+          },
+        }),
+      );
+      const { getByRole } = render(
+        <AssistantRuntimeProvider runtime={runtime}>
+          <ThreadListItemByIndexProvider index={0} archived>
+            <ThreadListItemPrimitiveUnarchive disabled={false}>
+              Restore
+            </ThreadListItemPrimitiveUnarchive>
+          </ThreadListItemByIndexProvider>
+        </AssistantRuntimeProvider>,
+      );
+      const button = getByRole("button", {
+        name: "Restore",
+      }) as HTMLButtonElement;
+      expect(button.disabled).toBe(!supported);
+      fireEvent.click(button);
+      if (supported) expect(onUnarchive).toHaveBeenCalledWith("archived");
+      else expect(onUnarchive).not.toHaveBeenCalled();
+    },
+  );
+});

package/src/primitives/threadListItem/ThreadListItemUnarchive.ts

@@ -8,8 +8,8 @@ import {
 import { useThreadListItemUnarchive as useThreadListItemUnarchiveBehavior } from "@assistant-ui/core/react";
 
 const useThreadListItemUnarchive = () => {
-  const { unarchive } = useThreadListItemUnarchiveBehavior();
-  return unarchive;
+  const { unarchive, disabled } = useThreadListItemUnarchiveBehavior();
+  return disabled ? null : unarchive;
 };
 
 export namespace ThreadListItemPrimitiveUnarchive {

package/src/primitives/threadListItem/ThreadListKeyboardNav.test.tsx

@@ -112,6 +112,31 @@ describe("thread list keyboard navigation", () => {
     expect(document.activeElement).toBe(first);
   });
 
+  it("skips disabled triggers in both directions without wrapping", () => {
+    const { container } = render(
+      <ThreadListPrimitiveRoot>
+        {[0, 1, 2].map((i) => (
+          <ThreadListItemPrimitiveRoot key={i}>
+            <ThreadListItemPrimitiveTrigger disabled={i === 1}>
+              item {i}
+            </ThreadListItemPrimitiveTrigger>
+          </ThreadListItemPrimitiveRoot>
+        ))}
+      </ThreadListPrimitiveRoot>,
+    );
+    const [first, , third] = triggers(container);
+
+    first!.focus();
+    expect(fireEvent.keyDown(first!, { key: "ArrowDown" })).toBe(false);
+    expect(document.activeElement).toBe(third);
+    expect(fireEvent.keyDown(third!, { key: "ArrowDown" })).toBe(true);
+    expect(document.activeElement).toBe(third);
+    expect(fireEvent.keyDown(third!, { key: "ArrowUp" })).toBe(false);
+    expect(document.activeElement).toBe(first);
+    expect(fireEvent.keyDown(first!, { key: "ArrowUp" })).toBe(true);
+    expect(document.activeElement).toBe(first);
+  });
+
   it("moves between an item and its More button with right/left arrows", () => {
     const { trigger, more } = renderItem();
 

package/src/tests/DataRenderers.test.tsx

@@ -15,7 +15,7 @@ import { useAui } from "@assistant-ui/store";
 import { AssistantRuntimeProvider } from "../context";
 import * as MessagePrimitive from "../primitives/message";
 import * as ThreadPrimitive from "../primitives/thread";
-import { useLocalRuntime } from "../legacy-runtime/runtime-cores/local/useLocalRuntime";
+import { useLocalRuntime } from "@assistant-ui/core/react";
 import {
   useAssistantDataUI,
   type ChatModelAdapter,