@assistant-ui/core 0.3.19 → 0.3.21

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

@@ -8,6 +8,7 @@ import type {
   RespondToToolApprovalOptions,
   StartRunConfig,
   ThreadSuggestion,
+  Unstable_RecordToolInteractionOptions,
 } from "../../runtime/interfaces/thread-runtime-core";
 
 import type {
@@ -52,10 +53,7 @@ import {
 } from "../tool-invocations/ToolInvocationTracker";
 import { EMPTY_QUEUE_ITEMS } from "../../runtime/queue/queue-item";
 import type { QuoteInfo } from "../../types/quote";
-import {
-  captureThreadRuntimeGeneration,
-  isThreadRuntimeGenerationCurrent,
-} from "../../runtime/utils/thread-runtime-lifecycle";
+import { captureThreadRuntimeGeneration } from "../../runtime/utils/thread-runtime-lifecycle";
 
 const EMPTY_ARRAY: readonly ThreadSuggestion[] = Object.freeze([]);
 
@@ -138,15 +136,20 @@ export class ExternalStoreThreadRuntimeCore
 
   private _converter = new ThreadMessageConverter();
 
-  // Ids the host was asked to delete via onDelete. The snapshot pass evicts
-  // them from the repository once the host's array no longer carries them;
-  // an id the host kept is dropped from the set without eviction.
-  // Branch-changing mutations (edit, branch switch, reload) invalidate the
-  // set, because after them the incoming array omits off-branch ids for
-  // reasons unrelated to deletion. Plain tail sends do not clear: a tail
-  // append cannot make a visible id absent, so id-absence stays unambiguous
-  // and a delete whose confirmation races a send keeps its eviction.
-  private _pendingDeleteEvictions = new Set<string>();
+  // Ids the host was asked to delete via onDelete, mapped to the onDelete
+  // calls still pending for them. The snapshot pass evicts them from the
+  // repository once the host's array no longer carries them; an id the host
+  // still carries after every onDelete call for it settled, resolved or
+  // rejected, is dropped from the map without eviction.
+  // Branch-changing mutations (edit, branch switch) invalidate the map,
+  // because after them the incoming array omits off-branch ids for reasons
+  // unrelated to deletion. A reload invalidates only the ids after the parent
+  // it regenerates from: the host keeps the prefix up to that parent, so an
+  // id absent from it is still a deletion. Plain tail sends do not clear: a
+  // tail append cannot make a visible id absent, so id-absence stays
+  // unambiguous and a delete whose confirmation races a send keeps its
+  // eviction.
+  private _pendingDeleteEvictions = new Map<string, Set<symbol>>();
 
   // Placeholder id for the upcoming assistant message, reused across snapshot
   // passes while the same tail message awaits its response so the placeholder
@@ -415,9 +418,12 @@ export class ExternalStoreThreadRuntimeCore
 
       if (this._pendingDeleteEvictions.size > 0) {
         const incomingIds = new Set(messages.map((m) => m.id));
-        for (const id of this._pendingDeleteEvictions) {
+        for (const [id, calls] of this._pendingDeleteEvictions) {
+          if (incomingIds.has(id)) {
+            if (calls.size === 0) this._pendingDeleteEvictions.delete(id);
+            continue;
+          }
           this._pendingDeleteEvictions.delete(id);
-          if (incomingIds.has(id)) continue;
           try {
             this.repository.getMessage(id);
           } catch {
@@ -475,6 +481,17 @@ export class ExternalStoreThreadRuntimeCore
       this._messages = messagesSnapshot;
     }
 
+    if (this._voiceMessages.length > 0) {
+      const hostIds = new Set(this._messages.map((message) => message.id));
+      const remaining = this._voiceMessages.filter(
+        (message) => !hostIds.has(message.id),
+      );
+      if (remaining.length !== this._voiceMessages.length) {
+        this._voiceMessages = remaining;
+        this._markVoiceMessagesDirty();
+      }
+    }
+
     if (repositoryChanged) {
       this._runTrackerUpdate(() => this._toolInvocations?.reset());
     }
@@ -637,23 +654,28 @@ export class ExternalStoreThreadRuntimeCore
   }
 
   public async append(rawMessage: AppendMessage): Promise<void> {
-    if (this._isVoiceMessage(rawMessage.sourceId))
+    let message = {
+      ...rawMessage,
+      parentId: this._resolveAppendParent(rawMessage.parentId),
+    };
+    if (this.voice) return this._appendToVoiceSession(message);
+    if (this._isVoiceMessage(message.sourceId))
       throw new Error("Voice transcript messages cannot be edited");
     // sourceId marks an edit send; the parent may coincide with the head
     // after a resync (e.g. cancelRun dropped the edited message).
     const isEdit =
-      rawMessage.sourceId != null ||
-      rawMessage.parentId !== (this.messages.at(-1)?.id ?? null);
+      message.sourceId != null ||
+      message.parentId !== (this._getBaseMessages().at(-1)?.id ?? null);
 
     // A transformed-queue send is stamped at flush; any other queue's
     // transform would gate against its own thread's messages, so those stamp
     // at send.
-    const message =
+    message =
       !isEdit &&
       this._store.queue &&
       this._store.queue === this._transformedQueue
-        ? rawMessage
-        : this.enrichAppendMetadata(rawMessage);
+        ? message
+        : this.enrichAppendMetadata(message);
 
     const generation = captureThreadRuntimeGeneration(this);
     this.ensureInitialized();
@@ -668,7 +690,7 @@ export class ExternalStoreThreadRuntimeCore
       if (initPromise) {
         await initPromise;
       }
-      if (!isThreadRuntimeGenerationCurrent(this, generation)) return;
+      if (generation.aborted) return;
 
       // Buffering does not start a run, so the tool-abort below must wait
       // until the queue flushes. By then the prior run (and its tools) has
@@ -695,7 +717,7 @@ export class ExternalStoreThreadRuntimeCore
     if (message.startRun ?? message.role === "user") {
       await this._toolInvocations?.abort({ discardPending: true });
     }
-    if (!isThreadRuntimeGenerationCurrent(this, generation)) return;
+    if (generation.aborted) return;
 
     if (isEdit) {
       if (!this._store.onEdit)
@@ -707,6 +729,35 @@ export class ExternalStoreThreadRuntimeCore
     }
   }
 
+  protected override _commitVoiceMessage(
+    message: ThreadMessage,
+  ): void | Promise<void> {
+    const generation = captureThreadRuntimeGeneration(this);
+    if (generation.aborted) {
+      this._dropVoiceMessage(message.id, false);
+      return;
+    }
+    const barrier = this._getVoiceCommitBarrier();
+    if (!barrier) {
+      this._store.onVoiceTranscript?.(message);
+      return;
+    }
+    // A React host recreates its callbacks on the render that ends the load,
+    // so the delivery reads the adapter current then rather than the callback
+    // that produced the message. The repository is the one conversation
+    // identity that survives those renders and moves when a host routes
+    // another conversation through this runtime; a host that swaps only its
+    // messages is indistinguishable from a load finishing.
+    const repository = this.repository;
+    return barrier.then(() => {
+      if (generation.aborted || this.repository !== repository) {
+        this._dropVoiceMessage(message.id, true);
+        return;
+      }
+      this._store.onVoiceTranscript?.(message);
+    });
+  }
+
   public async deleteMessage(messageId: string): Promise<void> {
     if (this._store.onDelete) {
       // The host owns deletion here, and it may decline (fail a server call,
@@ -718,12 +769,15 @@ export class ExternalStoreThreadRuntimeCore
       const wasVisible = this.repository
         .getMessages()
         .some((m) => m.id === messageId);
-      if (wasVisible) this._pendingDeleteEvictions.add(messageId);
+      const call = Symbol();
+      if (wasVisible) {
+        const calls = this._pendingDeleteEvictions.get(messageId) ?? new Set();
+        this._pendingDeleteEvictions.set(messageId, calls.add(call));
+      }
       try {
         await this._store.onDelete(messageId);
-      } catch (error) {
-        this._pendingDeleteEvictions.delete(messageId);
-        throw error;
+      } finally {
+        this._pendingDeleteEvictions.get(messageId)?.delete(call);
       }
       return;
     }
@@ -763,7 +817,14 @@ export class ExternalStoreThreadRuntimeCore
     }
 
     this.repository.deleteMessage(messageId);
-    this._messages = this.repository.getMessages();
+    this._publishRepositoryMessages();
+  }
+
+  // Notifies even when the visible messages are unchanged: deleting an
+  // off-branch message still changes the branch counts subscribers read.
+  private _publishRepositoryMessages() {
+    const messages = this.repository.getMessages();
+    if (!shallowArrayEqual(this._messages, messages)) this._messages = messages;
     this._notifySubscribers();
   }
 
@@ -788,10 +849,20 @@ export class ExternalStoreThreadRuntimeCore
   public async startRun(config: StartRunConfig): Promise<void> {
     if (!this._store.onReload)
       throw new Error("Runtime does not support reloading messages.");
+    if (this.voice)
+      throw new Error("Cannot start a run while a voice session is connected");
     if (this._isVoiceMessage(config.sourceId))
       throw new Error("Voice transcript messages cannot be reloaded");
 
-    this._pendingDeleteEvictions.clear();
+    const visible = this.repository.getMessages();
+    const kept = new Set(
+      visible
+        .slice(0, visible.findIndex((m) => m.id === config.parentId) + 1)
+        .map((m) => m.id),
+    );
+    for (const id of this._pendingDeleteEvictions.keys()) {
+      if (!kept.has(id)) this._pendingDeleteEvictions.delete(id);
+    }
 
     // Auto-abort in-flight client-side tool executions when a run reloads;
     // any results that land afterward would target a turn that no longer
@@ -804,6 +875,8 @@ export class ExternalStoreThreadRuntimeCore
   public async resumeRun(config: ResumeRunConfig): Promise<void> {
     if (!this._store.onResume)
       throw new Error("Runtime does not support resuming runs.");
+    if (this.voice)
+      throw new Error("Cannot start a run while a voice session is connected");
     if (this._isVoiceMessage(config.sourceId))
       throw new Error("Voice transcript messages cannot be reloaded");
 
@@ -898,7 +971,7 @@ export class ExternalStoreThreadRuntimeCore
         movedLeaf = { id: trailingUserLeaf.id, draft };
       }
     }
-    if (!movedLeaf) this._notifySubscribers();
+    this._publishRepositoryMessages();
 
     // The resync commits what the cancel left (a kept optimistic message, the
     // restored branch) back to the store a macrotask later. The store may move
@@ -906,7 +979,7 @@ export class ExternalStoreThreadRuntimeCore
     // tick. Read the repository at flush time and re-apply the rollbacks to
     // it, instead of stamping a snapshot captured above over the newer state.
     setTimeout(() => {
-      if (!isThreadRuntimeGenerationCurrent(this, generation)) return;
+      if (generation.aborted) return;
 
       this.dropEmptyOptimisticHead();
       if (movedLeaf) {
@@ -920,7 +993,8 @@ export class ExternalStoreThreadRuntimeCore
           this.composer.retractDraft(movedLeaf.draft);
         }
       }
-      this.updateMessages(this.repository.getMessages());
+      this._publishRepositoryMessages();
+      this.updateMessages(this._messages);
     }, 0);
   }
 
@@ -998,6 +1072,14 @@ export class ExternalStoreThreadRuntimeCore
     }
   }
 
+  public async unstable_recordToolInteraction(
+    options: Unstable_RecordToolInteractionOptions,
+  ): Promise<void> {
+    if (!this._store.unstable_onRecordToolInteraction)
+      throw new Error("Runtime does not support recording tool interactions.");
+    await this._store.unstable_onRecordToolInteraction(options);
+  }
+
   public override reset(initialMessages?: readonly ThreadMessageLike[]) {
     const repo = new MessageRepository();
     repo.import(ExportedMessageRepository.fromArray(initialMessages ?? []));

package/src/runtimes/inert/InertThreadRuntimeCore.test.ts

@@ -1,23 +1,27 @@
 import { describe, expect, it } from "vitest";
 import { BaseSubscribable } from "../../subscribable/subscribable";
+import type { ThreadMessage } from "../../types/message";
 import { ReadonlyThreadRuntimeCore } from "../readonly/ReadonlyThreadRuntimeCore";
 import { EMPTY_THREAD_CORE } from "../remote-thread-list/empty-thread-core";
 
 const READONLY_ERROR = /readonly thread/;
 const EMPTY_ERROR = /empty thread/;
 
-const SHARED_THROWING_METHODS = [
+const THREAD_MUTATION_METHODS = [
   "switchToBranch",
   "append",
   "deleteMessage",
   "startRun",
   "resumeRun",
+  "cancelRun",
   "unstable_notifySessionReset",
   "addToolResult",
   "resumeToolCall",
   "respondToToolApproval",
   "speak",
+  "stopSpeaking",
   "connectVoice",
+  "disconnectVoice",
   "muteVoice",
   "unmuteVoice",
   "submitFeedback",
@@ -29,12 +33,9 @@ const SHARED_THROWING_METHODS = [
 ] as const;
 
 const SHARED_THROWING_COMPOSER_METHODS = [
-  "setText",
   "setRole",
   "setRunConfig",
-  "send",
   "startDictation",
-  "setQuote",
 ] as const;
 
 const SHARED_NOOP_COMPOSER_METHODS = [
@@ -60,10 +61,6 @@ const cores = [
 ] as const;
 
 describe.each(cores)("%s shared inert surface", (_name, makeCore, error) => {
-  it.each(SHARED_THROWING_METHODS)("%s throws the core's error", (method) => {
-    expect(() => makeCore()[method]!()).toThrow(error);
-  });
-
   it.each(SHARED_THROWING_COMPOSER_METHODS)(
     "composer.%s throws the core's error",
     (method) => {
@@ -71,7 +68,7 @@ describe.each(cores)("%s shared inert surface", (_name, makeCore, error) => {
     },
   );
 
-  it.each(["addAttachment", "removeAttachment"] as const)(
+  it.each(["removeAttachment"] as const)(
     "composer.%s rejects with the core's error",
     async (method) => {
       await expect(makeCore().composer[method]!()).rejects.toThrow(error);
@@ -117,8 +114,6 @@ describe.each(cores)("%s shared inert surface", (_name, makeCore, error) => {
     expect(core.state).toBeNull();
     expect(core.suggestions).toEqual([]);
     expect(core.extras).toBeUndefined();
-    expect(core.isDisabled).toBe(false);
-    expect(core.isSendDisabled).toBe(false);
   });
 
   it("exposes an empty composer that accepts everything and holds nothing", () => {
@@ -136,9 +131,126 @@ describe.each(cores)("%s shared inert surface", (_name, makeCore, error) => {
     expect(composer.canCancel).toBe(false);
   });
 
-  it("throws one stable error object from every mutator", () => {
+  it("subscribeVoiceVolume and unstable_on hand back no-op unsubscribers", () => {
     const core = makeCore();
-    const thrown = SHARED_THROWING_METHODS.map((method) => {
+    expect(() => core.subscribeVoiceVolume(() => {})()).not.toThrow();
+    expect(() => core.unstable_on("runStart", () => {})()).not.toThrow();
+  });
+});
+
+describe("readonly thread mutations", () => {
+  it("reports a readonly thread disabled and the empty core enabled", () => {
+    const readonlyThread = new ReadonlyThreadRuntimeCore();
+    expect(readonlyThread.isDisabled).toBe(true);
+    expect(readonlyThread.isSendDisabled).toBe(true);
+    expect(EMPTY_THREAD_CORE.isDisabled).toBe(false);
+    expect(EMPTY_THREAD_CORE.isSendDisabled).toBe(false);
+  });
+
+  it("ignores composer input, sending, attachments and quotes", async () => {
+    const composer = new ReadonlyThreadRuntimeCore().composer;
+    expect(() => composer.setText("hello")).not.toThrow();
+    expect(() => composer.send()).not.toThrow();
+    expect(() =>
+      composer.setQuote({ text: "quoted", messageId: "message-1" }),
+    ).not.toThrow();
+    await expect(
+      composer.addAttachment(new File([], "test.txt")),
+    ).resolves.toBeUndefined();
+    expect(composer.text).toBe("");
+    expect(composer.quote).toBeUndefined();
+    expect(composer.attachments).toEqual([]);
+  });
+
+  it.each(["setText", "send", "setQuote"] as const)(
+    "empty core composer.%s still throws",
+    (method) => {
+      expect(() =>
+        (EMPTY_THREAD_CORE.composer[method] as () => void)(),
+      ).toThrow(EMPTY_ERROR);
+    },
+  );
+
+  it("empty core composer.addAttachment still rejects", async () => {
+    await expect(
+      EMPTY_THREAD_CORE.composer.addAttachment(new File([], "test.txt")),
+    ).rejects.toThrow(EMPTY_ERROR);
+  });
+
+  it("rejects interaction recording on empty threads and resolves on readonly threads", async () => {
+    await expect(
+      EMPTY_THREAD_CORE.unstable_recordToolInteraction!({
+        messageId: "message-1",
+        toolCallId: "call-1",
+        interaction: { type: "action", payload: {}, occurredAt: 0 },
+      }),
+    ).rejects.toThrow(EMPTY_ERROR);
+
+    const readonlyThread = new ReadonlyThreadRuntimeCore();
+    const messages: readonly ThreadMessage[] = [
+      {
+        id: "message-1",
+        role: "user" as const,
+        content: [{ type: "text" as const, text: "hello" }],
+        attachments: [],
+        createdAt: new Date(0),
+        status: { type: "complete" as const, reason: "stop" as const },
+        metadata: { custom: {} },
+      },
+    ];
+    readonlyThread.setMessages(messages);
+
+    await expect(
+      readonlyThread.unstable_recordToolInteraction!({
+        messageId: "message-1",
+        toolCallId: "call-1",
+        interaction: { type: "action", payload: {}, occurredAt: 0 },
+      }),
+    ).resolves.toBeUndefined();
+    expect(readonlyThread.messages).toBe(messages);
+  });
+
+  it.each(
+    THREAD_MUTATION_METHODS.filter(
+      (method) => method !== "exportExternalState",
+    ),
+  )("%s is ignored without changing messages", async (method) => {
+    const core = new ReadonlyThreadRuntimeCore() as unknown as AnyCore;
+    const messages = [
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "hi" }],
+        createdAt: new Date(0),
+        status: { type: "complete", reason: "stop" },
+        metadata: { custom: {} },
+      },
+    ];
+    core.setMessages(messages);
+
+    await core[method]!();
+
+    expect(core.messages).toBe(messages);
+  });
+
+  it("exportExternalState still throws on a readonly thread", () => {
+    expect(() => new ReadonlyThreadRuntimeCore().exportExternalState()).toThrow(
+      READONLY_ERROR,
+    );
+  });
+
+  it.each(THREAD_MUTATION_METHODS)(
+    "%s still throws on the empty core",
+    (method) => {
+      expect(() =>
+        (EMPTY_THREAD_CORE as unknown as AnyCore)[method]!(),
+      ).toThrow(EMPTY_ERROR);
+    },
+  );
+
+  it("empty core mutators throw one stable error object", () => {
+    const core = EMPTY_THREAD_CORE as unknown as AnyCore;
+    const thrown = THREAD_MUTATION_METHODS.map((method) => {
       try {
         core[method]!();
         return undefined;
@@ -151,30 +263,11 @@ describe.each(cores)("%s shared inert surface", (_name, makeCore, error) => {
     expect(thrown.every((e) => e === thrown[0])).toBe(true);
   });
 
-  it("throws a receiver TypeError when a mutator is detached", () => {
-    const detached = makeCore().append!;
+  it("an empty core mutator throws a receiver TypeError when detached", () => {
+    const detached = (EMPTY_THREAD_CORE as unknown as AnyCore).append!;
     expect(() => detached()).toThrow(TypeError);
   });
 
-  it("subscribeVoiceVolume and unstable_on hand back no-op unsubscribers", () => {
-    const core = makeCore();
-    expect(() => core.subscribeVoiceVolume(() => {})()).not.toThrow();
-    expect(() => core.unstable_on("runStart", () => {})()).not.toThrow();
-  });
-});
-
-describe("no-op versus throw divergences", () => {
-  it.each(["cancelRun", "stopSpeaking", "disconnectVoice"] as const)(
-    "%s is a no-op on the readonly core but throws on the empty core",
-    (method) => {
-      const readonly = new ReadonlyThreadRuntimeCore() as unknown as AnyCore;
-      expect(() => readonly[method]!()).not.toThrow();
-      expect(() =>
-        (EMPTY_THREAD_CORE as unknown as AnyCore)[method]!(),
-      ).toThrow(EMPTY_ERROR);
-    },
-  );
-
   it("readonly is not loading; empty is loading so it is not read as an empty conversation", () => {
     expect(new ReadonlyThreadRuntimeCore().isLoading).toBe(false);
     expect(EMPTY_THREAD_CORE.isLoading).toBe(true);
@@ -184,28 +277,6 @@ describe("no-op versus throw divergences", () => {
     expect(new ReadonlyThreadRuntimeCore().composer.isEditing).toBe(false);
     expect(EMPTY_THREAD_CORE.composer.isEditing).toBe(true);
   });
-
-  it("the two cores carry distinct error objects and messages", () => {
-    const grab = (fn: () => void) => {
-      try {
-        fn();
-        return undefined;
-      } catch (e) {
-        return e as Error;
-      }
-    };
-
-    const readonlyError = grab(() => new ReadonlyThreadRuntimeCore().append());
-    const emptyError = grab(() =>
-      (EMPTY_THREAD_CORE as unknown as AnyCore).append!(),
-    );
-
-    expect(readonlyError).not.toBe(emptyError);
-    expect(readonlyError?.message).toBe(
-      "This is a readonly thread. You cannot perform mutations on readonly threads.",
-    );
-    expect(emptyError?.message).toMatch(/placeholder for the main thread/);
-  });
 });
 
 describe("readonly notifications", () => {

package/src/runtimes/inert/InertThreadRuntimeCore.ts

@@ -1,6 +1,9 @@
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { ThreadMessage } from "../../types/message";
-import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
+import type {
+  ThreadRuntimeCore,
+  Unstable_RecordToolInteractionOptions,
+} from "../../runtime/interfaces/thread-runtime-core";
 import type { ExportedMessageRepository } from "../../runtime/utils/message-repository";
 import { BaseSubscribable } from "../../subscribable/subscribable";
 
@@ -140,6 +143,12 @@ export abstract class InertThreadRuntimeCore
     throw this.error;
   }
 
+  async unstable_recordToolInteraction(
+    _options: Unstable_RecordToolInteractionOptions,
+  ): Promise<void> {
+    throw this.error;
+  }
+
   speak(): void {
     throw this.error;
   }

package/src/runtimes/local/local-thread-runtime-core.edit-cancellation.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from "vitest";
+import { LocalRuntimeCore } from "./local-runtime-core";
+import type { AttachmentAdapter } from "../../adapters/attachment";
+
+describe("LocalThreadRuntimeCore edit cancellation", () => {
+  it("does not submit a cancelled edit after an attachment upload settles", async () => {
+    let finishUpload!: () => void;
+    const upload = new Promise<void>((resolve) => {
+      finishUpload = resolve;
+    });
+    const remove = vi.fn<AttachmentAdapter["remove"]>(async () => {});
+    const attachments: AttachmentAdapter = {
+      accept: "*",
+      add: async ({ file }) => ({
+        id: "file-1",
+        type: "document",
+        name: file.name,
+        file,
+        status: { type: "requires-action", reason: "composer-send" },
+      }),
+      send: async (attachment) => {
+        await upload;
+        return {
+          ...attachment,
+          status: { type: "complete" },
+          content: [{ type: "text", text: "uploaded" }],
+        };
+      },
+      remove,
+    };
+    const runtime = new LocalRuntimeCore(
+      {
+        adapters: {
+          chatModel: { run: async () => ({ content: [] }) },
+          attachments,
+        },
+      },
+      [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "original" }],
+        },
+      ],
+    );
+    const thread = runtime.threads.getMainThreadRuntimeCore();
+    const append = vi.spyOn(thread, "append").mockResolvedValue(undefined);
+    thread.beginEdit("u1");
+    const oldEdit = thread.getEditComposer("u1")!;
+    await oldEdit.addAttachment(
+      new File(["hello"], "file.txt", { type: "text/plain" }),
+    );
+    oldEdit.setText("cancelled change");
+    const send = oldEdit.send();
+    oldEdit.cancel();
+    thread.beginEdit("u1");
+    const replacement = thread.getEditComposer("u1")!;
+
+    finishUpload();
+    await send;
+
+    expect(append).not.toHaveBeenCalled();
+    expect(remove).toHaveBeenCalledOnce();
+    expect(remove.mock.calls[0]?.[0]).toMatchObject({
+      id: "file-1",
+      status: { type: "requires-action", reason: "composer-send" },
+    });
+    expect(thread.getEditComposer("u1")).toBe(replacement);
+  });
+});