@assistant-ui/core 0.3.19 → 0.3.20

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

@@ -6,7 +6,11 @@ import {
 import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
 import type { RealtimeVoiceAdapter } from "../adapters/voice";
 import type { ModelContextProvider } from "../model-context/types";
-import type { AppendMessage, ThreadMessage } from "../types/message";
+import type {
+  AppendMessage,
+  ThreadAssistantMessage,
+  ThreadMessage,
+} from "../types/message";
 import { createMessageQueue } from "../runtime/queue/message-queue";
 import { getThreadMessageText } from "../utils/text";
 import { invalidateThreadRuntime } from "../runtime/utils/thread-runtime-lifecycle";
@@ -27,21 +31,23 @@ const createUserMessage = (id: string, text = "Hello"): ThreadMessage =>
     },
   }) as ThreadMessage;
 
-const createAssistantMessage = (id: string, text = "Hi there"): ThreadMessage =>
-  ({
-    id,
-    role: "assistant" as const,
-    createdAt: new Date(),
-    content: [{ type: "text" as const, text }],
-    status: { type: "complete" as const, reason: "stop" as const },
-    metadata: {
-      unstable_state: null,
-      unstable_annotations: [],
-      unstable_data: [],
-      steps: [],
-      custom: {},
-    },
-  }) as ThreadMessage;
+const createAssistantMessage = (
+  id: string,
+  text = "Hi there",
+): ThreadAssistantMessage => ({
+  id,
+  role: "assistant" as const,
+  createdAt: new Date(),
+  content: [{ type: "text" as const, text }],
+  status: { type: "complete" as const, reason: "stop" as const },
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+});
 
 const createBaseAdapter = (
   overrides: Partial<ExternalStoreAdapter<ThreadMessage>> = {},
@@ -457,6 +463,63 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       expect(lastCall).toEqual([]);
     });
 
+    it.each([
+      { label: "without setMessages", withSetMessages: false, ids: ["u1"] },
+      { label: "with setMessages", withSetMessages: true, ids: [] },
+    ])(
+      "publishes only resolvable messages through the rollback $label",
+      async ({ withSetMessages, ids }) => {
+        const setMessages = vi.fn();
+        const adapter = () =>
+          createBaseAdapter({
+            messages: [createUserMessage("u1", "cancel me")],
+            isRunning: true,
+            onCancel: vi.fn(),
+            ...(withSetMessages && { setMessages }),
+          });
+        const core = new ExternalStoreThreadRuntimeCore(
+          contextProvider,
+          adapter(),
+        );
+        const unresolved = () =>
+          core.messages
+            .filter((m) => !core.getMessageById(m.id))
+            .map((m) => m.id);
+        expect(core.messages).toHaveLength(2);
+
+        core.cancelRun();
+        expect(unresolved()).toEqual([]);
+
+        core.__internal_setAdapter(adapter());
+        expect(unresolved()).toEqual([]);
+
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(unresolved()).toEqual([]);
+        expect(core.messages.map((m) => m.id)).toEqual(ids);
+      },
+    );
+
+    it("keeps the published messages array when cancel rolls nothing back", async () => {
+      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
+      const adapter = () =>
+        createBaseAdapter({
+          messages: [...messages],
+          isRunning: true,
+          onCancel: vi.fn(),
+        });
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        adapter(),
+      );
+      core.__internal_setAdapter(adapter());
+      const published = core.messages;
+
+      core.cancelRun();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(core.messages).toBe(published);
+    });
+
     it("evicts an empty optimistic head on cancel", async () => {
       const optimisticAssistant = {
         ...createAssistantMessage("server-msg", ""),
@@ -1304,6 +1367,9 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
 
 describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
   const createVoiceAdapter = () => {
+    let statusCallback:
+      | ((status: RealtimeVoiceAdapter.Status) => void)
+      | undefined;
     let transcriptCallback:
       | ((transcript: RealtimeVoiceAdapter.TranscriptItem) => void)
       | undefined;
@@ -1313,7 +1379,12 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
       disconnect: vi.fn(),
       mute: vi.fn(),
       unmute: vi.fn(),
-      onStatusChange: () => () => {},
+      onStatusChange: (callback) => {
+        statusCallback = callback;
+        return () => {
+          statusCallback = undefined;
+        };
+      },
       onTranscript: (callback) => {
         transcriptCallback = callback;
         return () => {
@@ -1325,17 +1396,20 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
     };
     return {
       adapter: { connect: () => session } satisfies RealtimeVoiceAdapter,
+      emitStatus: (status: RealtimeVoiceAdapter.Status) =>
+        statusCallback?.(status),
       emitTranscript: (transcript: RealtimeVoiceAdapter.TranscriptItem) =>
         transcriptCallback?.(transcript),
     };
   };
 
-  const createVoiceCore = () => {
+  const createVoiceCore = ({ commit = true }: { commit?: boolean } = {}) => {
     const voiceAdapter = createVoiceAdapter();
     const onNew = vi.fn(async () => {});
     const onEdit = vi.fn(async () => {});
     const onReload = vi.fn(async () => {});
     const onResume = vi.fn(async () => {});
+    const onVoiceTranscript = vi.fn();
     const core = new ExternalStoreThreadRuntimeCore(
       createContextProvider(),
       createBaseAdapter({
@@ -1343,6 +1417,7 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
         onEdit,
         onReload,
         onResume,
+        onVoiceTranscript,
         adapters: { voice: voiceAdapter.adapter },
       }),
     );
@@ -1352,18 +1427,139 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
       text: "Hello",
       isFinal: true,
     });
+    const transcript = core.messages[0]!;
+    if (commit) {
+      core.__internal_setAdapter(
+        createBaseAdapter({
+          messages: [transcript],
+          onNew,
+          onEdit,
+          onReload,
+          onResume,
+          onVoiceTranscript,
+          adapters: { voice: voiceAdapter.adapter },
+        }),
+      );
+      core.disconnectVoice();
+    }
     return {
       core,
       onNew,
       onEdit,
       onReload,
       onResume,
-      transcriptId: core.messages[0]!.id,
+      transcriptId: transcript.id,
     };
   };
 
-  it("rejects an edit resubmission of a transcript before reaching the store", async () => {
-    const { core, onNew, onEdit, transcriptId } = createVoiceCore();
+  it("hands a final transcript to onVoiceTranscript and drops the side list copy once the host carries it", () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onVoiceTranscript = vi.fn();
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        onVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+
+    try {
+      voiceAdapter.emitTranscript({
+        role: "user",
+        text: "Hello",
+        isFinal: true,
+      });
+      const message = core.messages[0]!;
+
+      expect(message.role).toBe("user");
+      expect(getThreadMessageText(message)).toBe("Hello");
+      expect(message.metadata.modality).toBe("voice");
+
+      expect(onVoiceTranscript).toHaveBeenCalledExactlyOnceWith(message);
+
+      core.__internal_setAdapter(
+        createBaseAdapter({
+          messages: [message],
+          onVoiceTranscript,
+          adapters: { voice: voiceAdapter.adapter },
+        }),
+      );
+
+      expect(core.messages.filter(({ id }) => id === message.id)).toEqual([
+        message,
+      ]);
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
+  it("keeps transcripts for the session when the host has no onVoiceTranscript", () => {
+    const voiceAdapter = createVoiceAdapter();
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({ adapters: { voice: voiceAdapter.adapter } }),
+    );
+    core.connectVoice();
+
+    voiceAdapter.emitTranscript({
+      role: "user",
+      text: "Hello",
+      isFinal: true,
+    });
+
+    expect(core.messages).toHaveLength(1);
+
+    core.disconnectVoice();
+
+    expect(core.messages).toEqual([]);
+  });
+
+  it("parents a send after the session ended on the last repository message", async () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onNew = vi.fn(async () => {});
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        onNew,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+
+    try {
+      voiceAdapter.emitTranscript({
+        role: "user",
+        text: "Hello",
+        isFinal: true,
+      });
+      const transcript = core.messages[0]!;
+      voiceAdapter.emitStatus({ type: "ended", reason: "finished" });
+
+      await core.append({
+        parentId: transcript.id,
+        sourceId: null,
+        role: "user",
+        content: [{ type: "text", text: "Follow up" }],
+        attachments: [],
+        metadata: { custom: {} },
+        createdAt: new Date(),
+        runConfig: {},
+        startRun: false,
+      });
+
+      expect(onNew).toHaveBeenCalledExactlyOnceWith(
+        expect.objectContaining({ parentId: null }),
+      );
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
+  it("rejects a text send while connected before reaching the store", async () => {
+    const { core, onNew, onEdit, transcriptId } = createVoiceCore({
+      commit: false,
+    });
     try {
       const edit: AppendMessage = {
         parentId: null,
@@ -1377,10 +1573,10 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
       };
 
       await expect(core.append(edit)).rejects.toThrow(
-        "Voice transcript messages cannot be edited",
+        "Cannot send a text message while a voice session is connected",
       );
       await expect(core.append({ ...edit, startRun: false })).rejects.toThrow(
-        "Voice transcript messages cannot be edited",
+        "Cannot send a text message while a voice session is connected",
       );
       expect(onNew).not.toHaveBeenCalled();
       expect(onEdit).not.toHaveBeenCalled();
@@ -1389,8 +1585,10 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
     }
   });
 
-  it("rejects reloading a transcript before reaching the store", async () => {
-    const { core, onReload, onResume, transcriptId } = createVoiceCore();
+  it("rejects a run while connected before reaching the store", async () => {
+    const { core, onReload, onResume, transcriptId } = createVoiceCore({
+      commit: false,
+    });
     try {
       await expect(
         core.startRun({
@@ -1398,14 +1596,18 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
           sourceId: transcriptId,
           runConfig: {},
         }),
-      ).rejects.toThrow("Voice transcript messages cannot be reloaded");
+      ).rejects.toThrow(
+        "Cannot start a run while a voice session is connected",
+      );
       await expect(
         core.resumeRun({
           parentId: null,
           sourceId: transcriptId,
           runConfig: {},
         }),
-      ).rejects.toThrow("Voice transcript messages cannot be reloaded");
+      ).rejects.toThrow(
+        "Cannot start a run while a voice session is connected",
+      );
       expect(onReload).not.toHaveBeenCalled();
       expect(onResume).not.toHaveBeenCalled();
     } finally {

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

@@ -1282,6 +1282,37 @@ describe("ExternalStoreThreadRuntimeCore - deleteMessage via setMessages", () =>
     }
   });
 
+  it("notifies the eviction when the host resyncs synchronously", async () => {
+    let current = [
+      message("u1", "user", "one"),
+      message("a1", "assistant", "two"),
+      message("u2", "user", "three"),
+      message("a2", "assistant", "four"),
+    ];
+    const store = (): ExternalStoreAdapter =>
+      makeStore({
+        messages: current,
+        setMessages: (m: import("../types/message").ThreadMessage[]) => {
+          current = m;
+          runtime.__internal_setAdapter(store());
+        },
+      });
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      store(),
+    );
+
+    const observed: (readonly string[])[] = [];
+    runtime.subscribe(() => {
+      observed.push(runtime.getBranches("a2"));
+    });
+
+    await runtime.deleteMessage("u2");
+
+    expect(runtime.messages.map((m) => m.id)).toEqual(["u1", "a1", "a2"]);
+    expect(observed.at(-1)).toEqual(["a2"]);
+  });
+
   it("evicts the deleted message on the onDelete path too", async () => {
     let current = [
       message("u1", "user", "hi"),

package/src/tests/external-thread-attachments.test.tsx

@@ -243,12 +243,12 @@ describe("ExternalThread attachments", () => {
 
   it("preserves foreign files that expose content", async () => {
     const aui = renderThread();
-    const foreignFile = {
-      name: "photo.png",
-      type: "image/png",
-      lastModified: 0,
-      content: [{ type: "text", text: "implementation detail" }],
-    } as File;
+    const foreignFile = Object.assign(
+      new File([""], "photo.png", { type: "image/png" }),
+      {
+        content: [{ type: "text", text: "implementation detail" }],
+      },
+    );
 
     await act(() => aui().thread.composer().addAttachment(foreignFile));
 
@@ -375,7 +375,7 @@ describe("ExternalThread attachments", () => {
 
   it("preserves composer state while attachments are prepared for send", async () => {
     let resolveSend!: (attachment: CompleteAttachment) => void;
-    const onNew = vi.fn();
+    const onNew = vi.fn<NonNullable<ExternalThreadProps["onNew"]>>();
     const file = new File(["data"], "notes.txt", { type: "text/plain" });
     const adapter = {
       accept: "*",
@@ -403,10 +403,10 @@ describe("ExternalThread attachments", () => {
     act(() => {
       composer().setText("first message");
       composer().setRole("assistant");
-      composer().setRunConfig({ model: "model-a" });
+      composer().setRunConfig({ custom: { model: "model-a" } });
       composer().send();
       composer().setRole("system");
-      composer().setRunConfig({ model: "model-b" });
+      composer().setRunConfig({ custom: { model: "model-b" } });
     });
     await act(async () => {
       resolveSend({
@@ -422,7 +422,7 @@ describe("ExternalThread attachments", () => {
     await waitFor(() => expect(onNew).toHaveBeenCalledTimes(1));
     expect(onNew.mock.calls[0]![0]).toMatchObject({
       role: "assistant",
-      runConfig: { model: "model-a" },
+      runConfig: { custom: { model: "model-a" } },
     });
   });
 
@@ -931,8 +931,8 @@ describe("cancelled edit sessions", () => {
         name: "notes.txt",
         contentType: "text/plain",
         file: new File(["data"], "notes.txt", { type: "text/plain" }),
-        status: { type: "pending", reason: "uploading", progress: 0 },
-      } as PendingAttachment);
+        status: { type: "running", reason: "uploading", progress: 0 },
+      });
       await addPromise.catch(() => {});
     });
 
@@ -964,15 +964,14 @@ describe("cancelled edit sessions", () => {
       onEdit: () => {},
       attachmentAdapter: {
         accept: "*",
-        add: async ({ file }: { file: File }) =>
-          ({
-            id: "pending-1",
-            type: "document",
-            name: file.name,
-            contentType: file.type,
-            file,
-            status: { type: "pending", reason: "uploading", progress: 0 },
-          }) as PendingAttachment,
+        add: async ({ file }: { file: File }) => ({
+          id: "pending-1",
+          type: "document",
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: { type: "running", reason: "uploading", progress: 0 },
+        }),
         send: async () => ({}) as never,
         remove,
       },
@@ -1037,8 +1036,8 @@ describe("cancelled edit sessions", () => {
         name: "notes.txt",
         contentType: "text/plain",
         file: new File(["data"], "notes.txt", { type: "text/plain" }),
-        status: { type: "pending", reason: "uploading", progress: 0 },
-      } as PendingAttachment);
+        status: { type: "running", reason: "uploading", progress: 0 },
+      });
       await addPromise;
     });
 

package/src/tests/external-thread-feedback.test.tsx

@@ -78,11 +78,19 @@ describe("ExternalThread feedback", () => {
     expect(withAdapter().thread.getState().capabilities.feedback).toBe(true);
   });
 
-  it("throws on submitFeedback when no adapter is configured", () => {
+  it("marks assistant feedback locally without an adapter", async () => {
     const { aui } = renderThreadWithProps({});
-    expect(() =>
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" }),
-    ).toThrow("Feedback adapter not configured");
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
+    });
+
+    await waitFor(() => {
+      expect(
+        aui().thread.message({ id: "a1" }).getState().metadata
+          .submittedFeedback,
+      ).toEqual({ type: "positive" });
+    });
   });
 
   it("submits feedback to the adapter and marks the assistant message", async () => {
@@ -90,23 +98,28 @@ describe("ExternalThread feedback", () => {
     const { aui } = renderThreadWithProps({ feedbackAdapter: adapter });
 
     await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
+      aui()
+        .thread.message({ id: "a1" })
+        .submitFeedback({ type: "positive", comment: "Helpful summary" });
     });
 
     expect(submit).toHaveBeenCalledTimes(1);
     expect(submit).toHaveBeenCalledWith({
       message: MESSAGES[1],
       type: "positive",
+      comment: "Helpful summary",
     });
     await waitFor(() => {
       expect(
         aui().thread.message({ id: "a1" }).getState().metadata
           .submittedFeedback,
-      ).toEqual({ type: "positive" });
+      ).toEqual({ type: "positive", comment: "Helpful summary" });
     });
 
     await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "negative" });
+      aui()
+        .thread.message({ id: "a1" })
+        .submitFeedback({ type: "negative", comment: "   " });
     });
 
     expect(submit).toHaveBeenLastCalledWith({

package/src/tests/external-thread-parity.test.tsx

@@ -254,7 +254,7 @@ describe("ExternalThread unset optional callbacks", () => {
     expect(() => part().resumeToolCall(undefined)).toThrow(
       "Runtime does not support resuming tool calls (onResumeToolCall is not set).",
     );
-    expect(() => aui().thread.resumeRun()).toThrow(
+    expect(() => aui().thread.resumeRun({ parentId: null })).toThrow(
       "Runtime does not support resuming runs (onResume is not set).",
     );
     expect(() => aui().thread.importExternalState({})).toThrow(

package/src/tests/message-queue.test.ts

@@ -1,5 +1,8 @@
 import { describe, it, expect, vi } from "vitest";
-import { createMessageQueue } from "../runtime/queue/message-queue";
+import {
+  createMessageQueue,
+  type MessageQueueDriver,
+} from "../runtime/queue/message-queue";
 import type { AppendMessage } from "../types/message";
 
 const msg = (text: string, extra?: Partial<AppendMessage>): AppendMessage => ({
@@ -35,6 +38,32 @@ describe("createMessageQueue", () => {
     expect(adapter.items).toHaveLength(0);
   });
 
+  it("does not advance a held queue when a run settles", () => {
+    const run = vi.fn();
+    const { adapter, hold, notifyIdle } = createMessageQueue({ run });
+
+    adapter.enqueue(msg("first"));
+    adapter.enqueue(msg("second"));
+    hold();
+    notifyIdle();
+
+    expect(run).toHaveBeenCalledOnce();
+    expect(prompts(adapter.items)).toEqual(["second"]);
+  });
+
+  it("advances a held queue once when released", () => {
+    const run = vi.fn();
+    const { adapter, hold, release } = createMessageQueue({ run });
+
+    hold();
+    adapter.enqueue(msg("first"));
+    release();
+    release();
+
+    expect(run).toHaveBeenCalledOnce();
+    expect(adapter.items).toHaveLength(0);
+  });
+
   it("drains FIFO across multiple queued messages", () => {
     const order: string[] = [];
     const run = vi.fn((m: AppendMessage) =>
@@ -438,7 +467,7 @@ describe("createMessageQueue", () => {
   describe("synchronous dispatch failures", () => {
     it("restores a message when the driver throws", () => {
       const error = new Error("dispatch failed");
-      const run = vi.fn(() => {
+      const run = vi.fn<MessageQueueDriver["run"]>(() => {
         throw error;
       });
       const { adapter } = createMessageQueue({ run });
@@ -446,7 +475,7 @@ describe("createMessageQueue", () => {
       expect(() => adapter.enqueue(msg("first"))).toThrow(error);
       expect(prompts(adapter.items)).toEqual(["first"]);
 
-      run.mockImplementation(() => undefined);
+      run.mockImplementation(() => {});
       adapter.enqueue(msg("second"));
 
       expect(run).toHaveBeenCalledTimes(2);
@@ -490,7 +519,10 @@ describe("createMessageQueue", () => {
       const error = new Error("transform failed");
       const run = vi.fn();
       const { adapter } = createMessageQueue({ run });
-      adapter.__internal_setDispatchTransform(() => {
+      const setDispatchTransform = adapter.__internal_setDispatchTransform;
+      if (setDispatchTransform === undefined)
+        throw new Error("expected dispatch transform support");
+      setDispatchTransform(() => {
         throw error;
       });
 
@@ -498,7 +530,7 @@ describe("createMessageQueue", () => {
       expect(run).not.toHaveBeenCalled();
       expect(prompts(adapter.items)).toEqual(["first"]);
 
-      adapter.__internal_setDispatchTransform((message) => message);
+      setDispatchTransform((message) => message);
       adapter.enqueue(msg("second"));
 
       expect(run).toHaveBeenCalledWith(
@@ -511,7 +543,7 @@ describe("createMessageQueue", () => {
     it("restores a steer when cancellation throws", () => {
       const error = new Error("cancel failed");
       const run = vi.fn();
-      const cancel = vi.fn(() => {
+      const cancel = vi.fn<NonNullable<MessageQueueDriver["cancel"]>>(() => {
         throw error;
       });
       const { adapter, notifyIdle } = createMessageQueue({ run, cancel });
@@ -523,7 +555,7 @@ describe("createMessageQueue", () => {
       notifyIdle();
       expect(run).toHaveBeenCalledOnce();
 
-      cancel.mockImplementation(() => undefined);
+      cancel.mockImplementation(() => {});
       adapter.enqueue(msg("later"));
       expect(run).toHaveBeenLastCalledWith(
         expect.objectContaining({
@@ -541,7 +573,10 @@ describe("createMessageQueue", () => {
       const { adapter, notifyIdle } = createMessageQueue({ run, cancel });
 
       adapter.enqueue(msg("active"));
-      adapter.__internal_setDispatchTransform(() => {
+      const setDispatchTransform = adapter.__internal_setDispatchTransform;
+      if (setDispatchTransform === undefined)
+        throw new Error("expected dispatch transform support");
+      setDispatchTransform(() => {
         throw error;
       });
 
@@ -550,7 +585,7 @@ describe("createMessageQueue", () => {
       expect(prompts(adapter.steerItems)).toEqual(["urgent"]);
 
       notifyIdle();
-      adapter.__internal_setDispatchTransform((message) => message);
+      setDispatchTransform((message) => message);
       adapter.enqueue(msg("later"));
 
       expect(run).toHaveBeenLastCalledWith(
@@ -880,7 +915,7 @@ describe("createMessageQueue", () => {
     subscribe(laterSubscriber);
 
     try {
-      expect(() => adapter.enqueue(msg("a"), { steer: false })).not.toThrow();
+      expect(() => adapter.enqueue(msg("a"))).not.toThrow();
       expect(run).toHaveBeenCalledTimes(1);
       expect(adapter.items).toHaveLength(0);
       expect(laterSubscriber).toHaveBeenCalledTimes(2);