@assistant-ui/core 0.3.5 → 0.3.7

package/src/runtimes/remote-thread-list/types.ts

@@ -1,8 +1,15 @@
-import type { ComponentType, PropsWithChildren } from "react";
 import type { ThreadMessage } from "../../types/message";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
 import type { AssistantStream } from "assistant-stream";
 
+/* oxlint-disable typescript/no-explicit-any -- structural stand-in for ComponentType without depending on react types */
+type RemoteThreadListProviderProps = { children?: any };
+
+export type RemoteThreadListProviderComponent =
+  | ((props: RemoteThreadListProviderProps) => any)
+  | (new (props: RemoteThreadListProviderProps) => any);
+/* oxlint-enable typescript/no-explicit-any */
+
 export type RemoteThreadInitializeResponse = {
   remoteId: string;
   externalId?: string | undefined;
@@ -54,7 +61,7 @@ export type RemoteThreadListAdapter = {
    * is unsupported and leaves thread context unavailable to downstream
    * consumers. Load data inside an always-mounted child instead.
    */
-  unstable_Provider?: ComponentType<PropsWithChildren> | undefined;
+  unstable_Provider?: RemoteThreadListProviderComponent | undefined;
 };
 
 export type RemoteThreadListOptions = {

package/src/store/clients/runtime-adapter.ts

@@ -1,8 +1,5 @@
-import {
-  Derived,
-  type ScopesConfig,
-  type AssistantClient,
-} from "@assistant-ui/store";
+import type { AssistantClient, ScopesConfig } from "@assistant-ui/store";
+import { Derived } from "@assistant-ui/store/client";
 import { ModelContext } from "./model-context-client";
 import { Suggestions } from "./suggestions";
 

package/src/store/clients/suggestions.ts

@@ -1,7 +1,7 @@
 import { useState } from "react";
 import { resource, withKey } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
-import { useClientLookup } from "@assistant-ui/store";
+import { useClientLookup } from "@assistant-ui/store/client";
 import type { SuggestionsState } from "../scopes/suggestions";
 import type { SuggestionState } from "../scopes/suggestion";
 

package/src/store/clients/thread-message-client.ts

@@ -7,7 +7,7 @@ import type { Attachment } from "../../types/attachment";
 import { useMemo, useState } from "react";
 import { useResource, resource, withKey } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
-import { useClientLookup } from "@assistant-ui/store";
+import { useClientLookup } from "@assistant-ui/store/client";
 import type { MessageState } from "../scopes/message";
 import type { PartState } from "../scopes/part";
 import { NoOpComposerClient } from "./no-op-composer-client";

package/src/store/index.ts

@@ -1,4 +1,5 @@
 /// <reference path="./scope-registration.ts" />
+/// <reference path="../react/types/store-augmentation.ts" />
 
 // scopes
 export type {
@@ -77,6 +78,36 @@ export type {
   ChainOfThoughtPart,
 } from "./scopes/chain-of-thought";
 
+// runtime wiring
+export { RuntimeAdapter } from "../react/RuntimeAdapter";
+export {
+  useExternalMessageConverter,
+  convertExternalMessages,
+  type JoinStrategy,
+} from "../react/runtimes/external-message-converter";
+export {
+  useStreamingTiming,
+  type StreamingTimingAccessors,
+  type StreamingTimingOptions,
+  type StreamingTimingState,
+} from "../react/runtimes/useStreamingTiming";
+export {
+  createRuntimeExtrasBrand,
+  type RuntimeExtrasBrand,
+} from "../runtime/utils/runtime-extras-brand";
+export { defineToolkit } from "../react/model-context/define-toolkit";
+export {
+  defineMcpToolkit,
+  type McpToolkitDefinition,
+  type McpToolkitEntry,
+  type McpToolkitToolConfig,
+} from "../react/model-context/define-mcp-toolkit";
+export type {
+  Toolkit,
+  ToolkitDefinition,
+  ToolkitDefinitionEntry,
+} from "../react/model-context/toolbox";
+
 // clients
 export { NoOpComposerClient } from "./clients/no-op-composer-client";
 export { Suggestions, type SuggestionConfig } from "./clients/suggestions";

package/src/store/runtime-clients/composer-runtime-client.ts

@@ -1,17 +1,15 @@
 import type { Unsubscribe } from "../../types/unsubscribe";
 import { useMemo, useEffect } from "react";
 import { useResource, resource, withKey } from "@assistant-ui/tap";
-import {
-  type ClientOutput,
-  useAssistantEmit,
-  useClientLookup,
-} from "@assistant-ui/store";
+import type { ClientOutput } from "@assistant-ui/store";
+import { useAssistantEmit, useClientLookup } from "@assistant-ui/store/client";
 import type {
   ComposerRuntime,
   EditComposerRuntime,
 } from "../../runtime/api/composer-runtime";
 import type { ComposerState } from "../scopes/composer";
 import type { QueueItemState } from "../scopes/queue-item";
+import type { QueuePlacement } from "../../runtime/queue/external-thread-queue-adapter";
 import { AttachmentRuntimeClient } from "./attachment-runtime-client";
 import { useSubscribable } from "./useSubscribable";
 
@@ -40,16 +38,17 @@ const ComposerAttachmentClientByIndex = resource(
 
 const useQueueItemClient = ({
   item,
-  onSteer,
+  onMove,
   onRemove,
 }: {
   item: QueueItemState;
-  onSteer: () => void;
+  onMove: (placement: QueuePlacement) => void;
   onRemove: () => void;
 }): ClientOutput<"queueItem"> => {
   return {
     getState: () => item,
-    steer: onSteer,
+    steer: () => onMove({ lane: "steer", insertAfter: null }),
+    move: onMove,
     remove: onRemove,
   };
 };
@@ -121,7 +120,7 @@ const useComposerClient = ({
         item.id,
         QueueItemClient({
           item,
-          onSteer: () => runtime.steerQueueItem(item.id),
+          onMove: (placement) => runtime.moveQueueItem(item.id, placement),
           onRemove: () => runtime.removeQueueItem(item.id),
         }),
       ),
@@ -171,7 +170,13 @@ const useComposerClient = ({
         return attachments.get(selector);
       }
     },
-    queueItem: (selector) => queueItems.get(selector),
+    queueItem: (selector) => {
+      if ("id" in selector) {
+        return queueItems.get({ key: selector.id });
+      } else {
+        return queueItems.get(selector);
+      }
+    },
     __internal_getRuntime: () => runtime,
   };
 };

package/src/store/runtime-clients/message-runtime-client.ts

@@ -1,10 +1,7 @@
 import { useMemo, useState } from "react";
 import { useResource, withKey, resource } from "@assistant-ui/tap";
-import {
-  type ClientOutput,
-  useClientLookup,
-  useClientResource,
-} from "@assistant-ui/store";
+import type { ClientOutput } from "@assistant-ui/store";
+import { useClientLookup, useClientResource } from "@assistant-ui/store/client";
 import type { MessageRuntime } from "../../runtime/api/message-runtime";
 import { useSubscribable } from "./useSubscribable";
 import { liveRef } from "./liveRef";

package/src/store/runtime-clients/thread-list-item-runtime-client.ts

@@ -1,7 +1,8 @@
 import type { Unsubscribe } from "../../types/unsubscribe";
 import { useEffect, useMemo } from "react";
 import { resource } from "@assistant-ui/tap";
-import { type ClientOutput, useAssistantEmit } from "@assistant-ui/store";
+import type { ClientOutput } from "@assistant-ui/store";
+import { useAssistantEmit } from "@assistant-ui/store/client";
 import type {
   ThreadListItemEventType,
   ThreadListItemRuntime,

package/src/store/runtime-clients/thread-list-runtime-client.ts

@@ -1,10 +1,7 @@
 import { useMemo } from "react";
 import { useResource, withKey, resource } from "@assistant-ui/tap";
-import {
-  type ClientOutput,
-  useClientLookup,
-  useClientResource,
-} from "@assistant-ui/store";
+import type { ClientOutput } from "@assistant-ui/store";
+import { useClientLookup, useClientResource } from "@assistant-ui/store/client";
 import type { ThreadListRuntime } from "../../runtime/api/thread-list-runtime";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
 import { useSubscribable } from "./useSubscribable";

package/src/store/runtime-clients/thread-runtime-client.ts

@@ -4,12 +4,12 @@ import type { ThreadRuntime } from "../../runtime/api/thread-runtime";
 import { useMemo, useEffect, type RefObject } from "react";
 import { useResource, resource, withKey } from "@assistant-ui/tap";
 import { liveRef } from "./liveRef";
+import type { ClientOutput } from "@assistant-ui/store";
 import {
-  type ClientOutput,
   useAssistantEmit,
   useClientLookup,
   useClientResource,
-} from "@assistant-ui/store";
+} from "@assistant-ui/store/client";
 import { ComposerClient } from "./composer-runtime-client";
 import { MessageClient } from "./message-runtime-client";
 import { useSubscribable } from "./useSubscribable";

package/src/store/scopes/composer.ts

@@ -13,8 +13,10 @@ import type { QueueItemState, QueueItemMethods } from "./queue-item";
 
 export type ComposerSendOptions = SendOptions & {
   /**
-   * Whether to steer (interrupt the current run and process this message immediately).
-   * When false (default), the message is queued and processed in order.
+   * Whether to steer (process this message next, interrupting the current run
+   * when the runtime supports it). Defaults to true while a queued run is in
+   * flight and false when idle. Pass false to queue behind the pending
+   * messages.
    */
   steer?: boolean;
 };
@@ -88,9 +90,9 @@ export type ComposerMethods = {
   setQuote(quote: QuoteInfo | undefined): void;
 
   /**
-   * Access a queue item by index.
+   * Access a queue item by index or id.
    */
-  queueItem(selector: { index: number }): QueueItemMethods;
+  queueItem(selector: { index: number } | { id: string }): QueueItemMethods;
 
   __internal_getRuntime?(): ComposerRuntime;
 };

package/src/store/scopes/queue-item.ts

@@ -1,19 +1,26 @@
+import type { FileMessagePart, TextMessagePart } from "../../types/message";
+import type { QueuePlacement } from "../../runtime/queue/external-thread-queue-adapter";
+
 export type QueueItemState = {
   readonly id: string;
+  /** @deprecated Derive from the text parts of `parts` instead. Removal after 2026-11-05. */
   readonly prompt: string;
+  readonly parts: readonly (FileMessagePart | TextMessagePart)[];
 };
 
 export const EMPTY_QUEUE_ITEMS: readonly QueueItemState[] = Object.freeze([]);
 
 export type QueueItemMethods = {
   getState(): QueueItemState;
+  /** @deprecated Use `move({ lane: "steer", insertAfter: null })` instead. Removal after 2026-11-05. */
   steer(): void;
+  move(placement: QueuePlacement): void;
   remove(): void;
 };
 
 export type QueueItemMeta = {
   source: "composer";
-  query: { index: number };
+  query: { type: "index"; index: number } | { type: "id"; id: string };
 };
 
 export type QueueItemClientSchema = {

package/src/tests/external-store-thread-runtime-core.test.ts

@@ -832,10 +832,12 @@ describe("ExternalStoreThreadRuntimeCore - initialize event replay", () => {
 describe("ExternalStoreThreadRuntimeCore - message queue", () => {
   const makeQueue = () => ({
     items: [] as never[],
+    steerItems: [] as never[],
     enqueue: vi.fn(),
     steer: vi.fn(),
+    move: vi.fn(),
+    edit: vi.fn(),
     remove: vi.fn(),
-    clear: vi.fn(),
   });
 
   const appendMessage = (
@@ -866,7 +868,7 @@ describe("ExternalStoreThreadRuntimeCore - message queue", () => {
     expect(withoutQueue.capabilities.queue).toBe(false);
   });
 
-  it("routes a tail append through queue.enqueue instead of onNew", async () => {
+  it("routes a tail append through the queue adapter instead of onNew", async () => {
     const queue = makeQueue();
     const onNew = vi.fn();
     const runtime = new ExternalStoreThreadRuntimeCore(
@@ -877,8 +879,48 @@ describe("ExternalStoreThreadRuntimeCore - message queue", () => {
     await runtime.append(appendMessage({ steer: true }));
 
     expect(onNew).not.toHaveBeenCalled();
+    expect(queue.enqueue).not.toHaveBeenCalled();
+    expect(queue.steer).toHaveBeenCalledTimes(1);
+  });
+
+  it("defaults a mid-run send to steer and an idle send to enqueue", async () => {
+    const queue = makeQueue();
+    const running = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ queue, onNew: vi.fn(), isRunning: true }),
+    );
+    await running.append(
+      appendMessage({ parentId: running.messages.at(-1)?.id ?? null }),
+    );
+    expect(queue.steer).toHaveBeenCalledTimes(1);
+    expect(queue.enqueue).not.toHaveBeenCalled();
+
+    const idleQueue = makeQueue();
+    const idle = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ queue: idleQueue, onNew: vi.fn(), isRunning: false }),
+    );
+    await idle.append(
+      appendMessage({ parentId: idle.messages.at(-1)?.id ?? null }),
+    );
+    expect(idleQueue.enqueue).toHaveBeenCalledTimes(1);
+    expect(idleQueue.steer).not.toHaveBeenCalled();
+  });
+
+  it("queues behind pending items when steer is explicitly false mid-run", async () => {
+    const queue = makeQueue();
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ queue, onNew: vi.fn(), isRunning: true }),
+    );
+    await runtime.append(
+      appendMessage({
+        steer: false,
+        parentId: runtime.messages.at(-1)?.id ?? null,
+      }),
+    );
     expect(queue.enqueue).toHaveBeenCalledTimes(1);
-    expect(queue.enqueue.mock.calls[0]![1]).toEqual({ steer: true });
+    expect(queue.steer).not.toHaveBeenCalled();
   });
 
   it("does not abort in-flight tools when buffering a queued send", async () => {
@@ -913,7 +955,7 @@ describe("ExternalStoreThreadRuntimeCore - message queue", () => {
     expect(abort).toHaveBeenCalledTimes(1);
   });
 
-  it("clears the queue on cancel, reload, and edit", async () => {
+  it("keeps the queue on cancel, reload, and edit", async () => {
     const queue = makeQueue();
     const runtime = new ExternalStoreThreadRuntimeCore(
       mockContextProvider,
@@ -926,29 +968,30 @@ describe("ExternalStoreThreadRuntimeCore - message queue", () => {
     );
 
     runtime.cancelRun();
-    expect(queue.clear).toHaveBeenCalledWith("cancel-run");
-
     await runtime.startRun({ parentId: null, sourceId: null, runConfig: {} });
-    expect(queue.clear).toHaveBeenCalledWith("reload");
-
     // a non-tail parentId routes to the edit branch
     await runtime.append(appendMessage({ parentId: "not-the-tail" }));
-    expect(queue.clear).toHaveBeenCalledWith("edit");
+
+    expect(queue.remove).not.toHaveBeenCalled();
+    expect(queue.move).not.toHaveBeenCalled();
   });
 
-  it("delegates getQueueItems / steer / remove to the adapter", () => {
+  it("delegates queue reads / move / remove to the adapter", () => {
     const queue = makeQueue();
-    const items = [{ id: "q1", prompt: "queued" }];
+    const items = [{ id: "q1", prompt: "queued", parts: [] }];
+    const steerItems = [{ id: "s1", prompt: "steered", parts: [] }];
     queue.items = items as never;
+    queue.steerItems = steerItems as never;
     const runtime = new ExternalStoreThreadRuntimeCore(
       mockContextProvider,
       makeStore({ queue }),
     );
 
     expect(runtime.getQueueItems()).toBe(items);
-    runtime.steerQueueItem("q1");
+    expect(runtime.getSteerQueueItems()).toBe(steerItems);
+    runtime.moveQueueItem("q1", { lane: "steer" });
     runtime.removeQueueItem("q1");
-    expect(queue.steer).toHaveBeenCalledWith("q1");
+    expect(queue.move).toHaveBeenCalledWith("q1", { lane: "steer" });
     expect(queue.remove).toHaveBeenCalledWith("q1");
   });
 });

package/src/tests/framework-neutral-boundary.test.ts

@@ -0,0 +1,257 @@
+/// <reference types="node" />
+import { describe, expect, it } from "vitest";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+
+const SRC_DIR = resolve(__dirname, "..");
+
+const FORBIDDEN_MODULES = new Set([
+  "react",
+  "react/jsx-runtime",
+  "@assistant-ui/store",
+  "@assistant-ui/tap",
+]);
+
+const STORE_ALLOWED_REACT_NAMES = new Set([
+  "useState",
+  "useReducer",
+  "useRef",
+  "useMemo",
+  "useCallback",
+  "useEffect",
+  "useLayoutEffect",
+  "useInsertionEffect",
+  "useEffectEvent",
+  "useSyncExternalStore",
+  "useDebugValue",
+  "use",
+  "useContext",
+  "createContext",
+]);
+
+const IMPORT_RE =
+  /(?:import|export)\s+(?:type\s+)?(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+))*\s+from\s+)?["']([^"']+)["']/g;
+
+const SIDE_EFFECT_IMPORT_RE = /import\s+["']([^"']+)["']/g;
+
+const EXPORT_STAR_RE = /export\s+\*\s+from\s+["']([^"']+)["']/g;
+
+const DYNAMIC_IMPORT_RE = /\b(?:import|require)\s*\(\s*["']([^"']+)["']\s*\)/g;
+
+const FROM_REACT_RE =
+  /(?:import|export)\s+(?:type\s+)?([\s\S]*?)\s+from\s+["']react["']/g;
+
+function resolveRelative(fromFile: string, spec: string): string | null {
+  if (!spec.startsWith(".")) return null;
+  const base = resolve(dirname(fromFile), spec);
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    join(base, "index.ts"),
+    join(base, "index.tsx"),
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function collectImports(content: string): string[] {
+  const specs: string[] = [];
+  for (const re of [
+    IMPORT_RE,
+    SIDE_EFFECT_IMPORT_RE,
+    EXPORT_STAR_RE,
+    DYNAMIC_IMPORT_RE,
+  ]) {
+    re.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = re.exec(content)) !== null) {
+      specs.push(match[1]!);
+    }
+  }
+  return specs;
+}
+
+function walkFrom(entry: string): { forbidden: string[]; jsxFiles: string[] } {
+  const visited = new Set<string>();
+  const queue = [entry];
+  const forbidden: string[] = [];
+
+  while (queue.length > 0) {
+    const file = queue.pop()!;
+    if (visited.has(file)) continue;
+    visited.add(file);
+
+    const content = readFileSync(file, "utf-8");
+    const specs = collectImports(content);
+
+    for (const spec of specs) {
+      if (FORBIDDEN_MODULES.has(spec)) {
+        forbidden.push(`${relative(SRC_DIR, file)} imports "${spec}"`);
+        continue;
+      }
+      const resolved = resolveRelative(file, spec);
+      if (resolved && !visited.has(resolved)) {
+        queue.push(resolved);
+      }
+    }
+  }
+
+  const jsxFiles = [...visited]
+    .filter((file) => file.endsWith(".tsx"))
+    .map((file) => relative(SRC_DIR, file));
+
+  return { forbidden, jsxFiles };
+}
+
+function nonTypeImportNames(clause: string): string[] {
+  const names: string[] = [];
+  const trimmed = clause.trim();
+  if (trimmed.startsWith("type ")) return names;
+  if (/^\*\s+as\s+\w+$/.test(trimmed)) return names;
+
+  const defaultAndNamed = trimmed.match(/^(\w+)\s*,\s*\{([\s\S]*)\}$/);
+  const namedOnly = trimmed.match(/^\{([\s\S]*)\}$/);
+  const defaultOnly = trimmed.match(/^(\w+)$/);
+
+  let namedBody = "";
+  if (defaultAndNamed) {
+    names.push(defaultAndNamed[1]!);
+    namedBody = defaultAndNamed[2]!;
+  } else if (namedOnly) {
+    namedBody = namedOnly[1]!;
+  } else if (defaultOnly) {
+    names.push(defaultOnly[1]!);
+    return names;
+  } else {
+    return names;
+  }
+
+  for (const part of namedBody.split(",")) {
+    const p = part.trim();
+    if (!p || p.startsWith("type ")) continue;
+    const asMatch = p.match(/^(\w+)(?:\s+as\s+\w+)?$/);
+    if (asMatch) names.push(asMatch[1]!);
+  }
+  return names;
+}
+
+describe("framework neutral boundary", () => {
+  it("the default entry graph must not import react, react/jsx-runtime, @assistant-ui/tap, or @assistant-ui/store", () => {
+    const { forbidden, jsxFiles } = walkFrom(resolve(SRC_DIR, "index.ts"));
+    expect(
+      forbidden,
+      `The default entry must stay loadable without react, @assistant-ui/tap, or @assistant-ui/store installed.\n` +
+        `These modules in the src/index.ts graph import a forbidden package:\n` +
+        forbidden.map((f) => `  - ${f}`).join("\n"),
+    ).toEqual([]);
+    expect(
+      jsxFiles,
+      `The JSX transform injects react/jsx-runtime at build time, so the default entry graph must not contain .tsx files:\n` +
+        jsxFiles.map((f) => `  - ${f}`).join("\n"),
+    ).toEqual([]);
+  });
+
+  it("the internal entry graph must not import react, react/jsx-runtime, @assistant-ui/tap, or @assistant-ui/store", () => {
+    const { forbidden, jsxFiles } = walkFrom(resolve(SRC_DIR, "internal.ts"));
+    expect(
+      forbidden,
+      "The internal entry must stay loadable without react, react/jsx-runtime, @assistant-ui/tap, or @assistant-ui/store installed.\nViolations:\n" +
+        forbidden.map((f) => `  - ${f}`).join("\n"),
+    ).toEqual([]);
+    expect(
+      jsxFiles,
+      `The JSX transform injects react/jsx-runtime at build time, so the internal entry graph must not contain .tsx files:\n` +
+        jsxFiles.map((f) => `  - ${f}`).join("\n"),
+    ).toEqual([]);
+  });
+
+  it("the store entry graphs stay hostable inside a tap root", () => {
+    const violations: string[] = [];
+    const jsxFiles: string[] = [];
+    const visited = new Set<string>();
+    const pending = [
+      resolve(SRC_DIR, "store/index.ts"),
+      resolve(SRC_DIR, "store/internal.ts"),
+    ];
+
+    // Walks the runtime graph only: type-only imports are erased at build, so
+    // they neither carry runtime dependencies nor get traversed. This is also
+    // why type imports may keep using the @assistant-ui/store barrel: the
+    // augmentations target that specifier, and splitting types across entries
+    // would fork the ScopeRegistry seen by src-mapped consumers.
+    const RUNTIME_IMPORT_RE =
+      /(?:^|\n)\s*(?:import|export)\s+(?!type\b)(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\*|\w+(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+))?)\s+from\s+)?["']([^"']+)["']/g;
+
+    const collectRuntimeImports = (content: string): string[] => {
+      const specs: string[] = [];
+      for (const re of [RUNTIME_IMPORT_RE, DYNAMIC_IMPORT_RE]) {
+        re.lastIndex = 0;
+        let match: RegExpExecArray | null;
+        while ((match = re.exec(content)) !== null) {
+          specs.push(match[1]!);
+        }
+      }
+      return specs;
+    };
+
+    while (pending.length > 0) {
+      const file = pending.pop()!;
+      if (visited.has(file)) continue;
+      visited.add(file);
+      if (file.endsWith(".tsx")) jsxFiles.push(relative(SRC_DIR, file));
+
+      const content = readFileSync(file, "utf-8");
+
+      for (const spec of collectRuntimeImports(content)) {
+        if (spec === "react/jsx-runtime") {
+          violations.push(
+            `${relative(SRC_DIR, file)} imports "react/jsx-runtime"`,
+          );
+        }
+        if (spec === "@assistant-ui/store") {
+          violations.push(
+            `${relative(SRC_DIR, file)} value-imports the "@assistant-ui/store" barrel; use "@assistant-ui/store/client"`,
+          );
+        }
+        const resolved = resolveRelative(file, spec);
+        if (resolved && !visited.has(resolved)) {
+          pending.push(resolved);
+        }
+      }
+
+      FROM_REACT_RE.lastIndex = 0;
+      let match: RegExpExecArray | null;
+      while ((match = FROM_REACT_RE.exec(content)) !== null) {
+        if (/^(?:import|export)\s+type\b/.test(match[0]!)) continue;
+        const clause = match[1]!;
+        if (clause.trimStart().startsWith("type ")) continue;
+        for (const name of nonTypeImportNames(clause)) {
+          if (!STORE_ALLOWED_REACT_NAMES.has(name)) {
+            violations.push(
+              `${relative(SRC_DIR, file)} imports "${name}" from "react"`,
+            );
+          }
+        }
+      }
+    }
+
+    expect(
+      violations,
+      `The store entry graphs run inside tap roots on every framework, so they may ` +
+        `only use react names the tap shim dispatches, never react/jsx-runtime, and ` +
+        `never the @assistant-ui/store barrel (whose module scope requires React).\n` +
+        `Violations:\n` +
+        violations.map((f) => `  - ${f}`).join("\n"),
+    ).toEqual([]);
+    expect(
+      jsxFiles,
+      `The JSX transform injects react/jsx-runtime at build time, so the store entry graphs must not contain .tsx files:\n` +
+        jsxFiles.map((f) => `  - ${f}`).join("\n"),
+    ).toEqual([]);
+  });
+});