@agent-native/toolkit 0.23.1 → 0.198.2

package/dist/composer/TiptapComposer.spec.js

@@ -1,1780 +0,0 @@
-// @vitest-environment happy-dom
-import { AssistantRuntimeProvider, useLocalRuntime, } from "@assistant-ui/react";
-import { Editor } from "@tiptap/core";
-import React, { act } from "react";
-import { createRoot } from "react-dom/client";
-import { toast } from "sonner";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("sonner", () => ({
-    toast: { success: vi.fn() },
-}));
-import { TooltipProvider } from "../ui/tooltip.js";
-import { getComposerDraftKey } from "./draft-key.js";
-import { canSubmitComposerContent, canRemoveVoicePreview, compactComposerModelName, compactComposerReasoningEffortLabel, composerModelCostTier, createTiptapComposerExtensions, displayableComposerModeMessage, getComposerSendTooltipKey, getComposerSubmitIntentForEnterKey, getComposerPopoverPosition, getComposerPopoverAnchorPosition, getComposerReasoningEffortOptions, getOversizedDocumentAttachmentError, handleComposerFileDrop, insertComposerHardBreakAndScrollIntoView, isOpenAiModelProviderGroup, isComposerEditorUsable, formatVoiceTranscriptForComposer, hasConfiguredCloudProvider, MODEL_SELECTOR_POPOVER_STYLE, mentionItemMatchesQuery, resolveContextChipBackspaceAction, resolveComposerPrimaryAction, shouldRenderModelSelector, shouldShowModelSelectorSkeleton, shouldShowOnlyConnectPath, TiptapComposer, } from "./TiptapComposer.js";
-const emptyChatModelAdapter = {
-    async *run() { },
-};
-let container;
-let root;
-beforeEach(() => {
-    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
-    localStorage.clear();
-    container = document.createElement("div");
-    document.body.appendChild(container);
-    root = createRoot(container);
-});
-afterEach(() => {
-    act(() => root.unmount());
-    container.remove();
-    vi.unstubAllGlobals();
-});
-describe("createTiptapComposerExtensions", () => {
-    it("refreshes the rendered placeholder after a locale change", () => {
-        let placeholder = "Ask the agent...";
-        const element = document.createElement("div");
-        const editor = new Editor({
-            element,
-            extensions: createTiptapComposerExtensions(() => placeholder),
-        });
-        expect(element
-            .querySelector(".is-editor-empty")
-            ?.getAttribute("data-placeholder")).toBe("Ask the agent...");
-        placeholder = "Frag den Agenten...";
-        editor.view.dispatch(editor.state.tr.setSelection(editor.state.selection));
-        expect(element
-            .querySelector(".is-editor-empty")
-            ?.getAttribute("data-placeholder")).toBe("Frag den Agenten...");
-        editor.destroy();
-    });
-    it("rejects a truthy editor after BFCache/remount destruction", () => {
-        const editor = new Editor({
-            element: document.createElement("div"),
-            extensions: createTiptapComposerExtensions(() => "Message agent..."),
-        });
-        expect(isComposerEditorUsable(editor)).toBe(true);
-        editor.destroy();
-        expect(editor).toBeTruthy();
-        expect(editor.isDestroyed).toBe(true);
-        expect(isComposerEditorUsable(editor)).toBe(false);
-        expect(() => {
-            if (isComposerEditorUsable(editor))
-                editor.commands.clearContent();
-        }).not.toThrow();
-    });
-    it("offers explicit effort levels without legacy Auto", () => {
-        expect(getComposerReasoningEffortOptions("auto")).toEqual([
-            "low",
-            "medium",
-            "high",
-            "xhigh",
-            "max",
-        ]);
-        expect(getComposerReasoningEffortOptions("claude-sonnet-5")).not.toContain("auto");
-    });
-    it("uses model tiers in the composer preview", () => {
-        expect(compactComposerModelName("gpt-5.6-sol")).toBe("Sol");
-        expect(compactComposerModelName("gpt-5-6-terra")).toBe("Terra");
-        expect(compactComposerModelName("openai/gpt-5.6-luna")).toBe("Luna");
-        expect(compactComposerModelName("gpt-6-sol")).toBe("Sol");
-        expect(compactComposerModelName("openai/gpt-6-luna")).toBe("Luna");
-        expect(compactComposerModelName("openai/gpt-6-astra")).toBe("Astra");
-        expect(compactComposerModelName("openai/gpt-6-astra-pro")).toBe("Astra Pro");
-        expect(compactComposerModelName("google/gemini-3.8-flash")).toBe("Flash");
-        expect(compactComposerModelName("qwen/qwen3.8-max-0902")).toBe("Max");
-        expect(compactComposerModelName("claude-sonnet-5")).toBe("Sonnet");
-        expect(compactComposerModelName("anthropic/claude-opus-5.5")).toBe("Opus");
-        expect(compactComposerModelName("gemini-3-5-flash-lite")).toBe("Flash-Lite");
-        expect(compactComposerModelName("grok-code-fast")).toBe("Code Fast");
-        expect(compactComposerModelName("deepseek-v3-1")).toBe("DeepSeek");
-        expect(compactComposerModelName("codex-cli")).toBe("Codex");
-        expect(compactComposerReasoningEffortLabel("medium")).toBe("Med");
-        expect(compactComposerReasoningEffortLabel("minimal")).toBe("Min");
-        expect(compactComposerReasoningEffortLabel("xhigh")).toBe("XHigh");
-        const translate = (key, options) => key === "agentChat.composer.defaultModel"
-            ? "Standardmodell"
-            : key === "agentChat.composer.reasoningMediumShort"
-                ? "Mittel"
-                : String(options?.defaultValue ?? key);
-        expect(compactComposerModelName("auto", translate)).toBe("Standardmodell");
-        expect(compactComposerReasoningEffortLabel("medium", translate)).toBe("Mittel");
-    });
-    it("limits Codex to OpenAI model providers", () => {
-        expect(isOpenAiModelProviderGroup({
-            engine: "builder",
-            label: "OpenAI",
-            models: ["gpt-5.6-luna"],
-        })).toBe(true);
-        expect(isOpenAiModelProviderGroup({
-            engine: "ai-sdk:google",
-            label: "Gemini",
-            models: ["gemini-3.5-flash"],
-        })).toBe(false);
-        expect(isOpenAiModelProviderGroup({
-            engine: "custom-gateway",
-            label: "Custom",
-            models: ["gpt-5.6-luna"],
-        })).toBe(true);
-        expect(isOpenAiModelProviderGroup({
-            engine: "ai-sdk:openrouter",
-            label: "OpenRouter",
-            models: ["openai/gpt-5.6-luna"],
-        })).toBe(true);
-        expect(isOpenAiModelProviderGroup({
-            engine: "codex-cli",
-            label: "OpenAI",
-            models: ["gpt-5.6-luna"],
-        })).toBe(true);
-        expect(isOpenAiModelProviderGroup({
-            engine: "codex-cli",
-            label: "OpenAI",
-            models: ["codex-cli"],
-        })).toBe(false);
-    });
-    it("keeps the prompt composer schema minimal and restores legacy draft HTML", () => {
-        const editor = new Editor({
-            element: document.createElement("div"),
-            extensions: createTiptapComposerExtensions(() => "Message agent..."),
-        });
-        expect(Object.keys(editor.schema.marks)).toEqual([]);
-        expect(Object.keys(editor.schema.nodes).sort()).toEqual([
-            "doc",
-            "fileReference",
-            "hardBreak",
-            "mentionReference",
-            "paragraph",
-            "skillReference",
-            "text",
-        ]);
-        expect(() => {
-            editor.commands.setContent(`
-        <h1>Legacy heading</h1>
-        <ul><li>Legacy list item</li></ul>
-        <p><a href="https://example.com">Legacy link</a></p>
-        <p><span data-type="file-reference" path="/tmp/example.ts"></span></p>
-      `);
-        }).not.toThrow();
-        expect(editor.getText()).toContain("Legacy heading");
-        expect(editor.getText()).toContain("Legacy list item");
-        expect(editor.getText()).toContain("Legacy link");
-        expect(editor.getHTML()).toContain('data-type="file-reference"');
-        editor.destroy();
-    });
-    it("restores a scoped draft before a seeded prompt without crossing scopes", async () => {
-        const scope = "draft-recovery:test";
-        const draftEditor = new Editor({
-            element: document.createElement("div"),
-            extensions: createTiptapComposerExtensions(() => "Message agent..."),
-        });
-        draftEditor.commands.setContent("<p>Saved prompt</p>");
-        localStorage.setItem(getComposerDraftKey(scope), draftEditor.getHTML());
-        draftEditor.destroy();
-        expect(localStorage.getItem(getComposerDraftKey(scope))).toContain("Saved prompt");
-        const focusRef = React.createRef();
-        const onTextChange = vi.fn();
-        let harnessRuntime;
-        function Harness({ currentScope, plusMenuMode = "hidden", }) {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            harnessRuntime = runtime;
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                draftScope: currentScope,
-                initialText: "Seed prompt",
-                initialTextKey: "seed",
-                includeDefaultSlashSkills: false,
-                onTextChange,
-                plusMenuMode,
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            localStorage.setItem(getComposerDraftKey(), "<p>Legacy prompt</p>");
-            root.render(React.createElement(Harness, { currentScope: undefined }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(container.querySelector(".agent-composer-prosemirror")?.textContent).toBe("Seed prompt");
-        expect(localStorage.getItem(getComposerDraftKey())).toContain("Legacy prompt");
-        await act(async () => {
-            root.render(React.createElement(Harness, { currentScope: scope }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(container.querySelector(".agent-composer-prosemirror")?.textContent).toBe("Saved prompt");
-        expect(onTextChange).toHaveBeenCalledWith("Saved prompt");
-        act(() => focusRef.current?.setText("Typed prompt"));
-        expect(localStorage.getItem(getComposerDraftKey(scope))).toContain("Typed prompt");
-        act(() => focusRef.current?.insertReference({
-            label: "Pending reference",
-            refType: "file",
-            refPath: "/tmp/pending.txt",
-        }));
-        act(() => window.dispatchEvent(new Event("pagehide")));
-        expect(localStorage.getItem(getComposerDraftKey(scope))).toContain("Pending reference");
-        await act(async () => {
-            await harnessRuntime?.thread.composer.addAttachment({
-                id: "scope-a-attachment",
-                type: "document",
-                name: "scope-a.txt",
-                content: [],
-            });
-        });
-        expect(harnessRuntime?.thread.composer.getState().attachments).toHaveLength(1);
-        await act(async () => {
-            root.render(React.createElement(Harness, {
-                currentScope: scope,
-                plusMenuMode: "full",
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => {
-            container
-                .querySelector('button[aria-label="Add..."]')
-                ?.click();
-        });
-        act(() => {
-            Array.from(document.querySelectorAll("button"))
-                .find((button) => button.textContent?.trim() === "Schedule Task")
-                ?.click();
-        });
-        expect(container.querySelector('[data-agent-composer-slot="mode-row"]')).not.toBeNull();
-        await act(async () => {
-            root.render(React.createElement(Harness, {
-                currentScope: "draft-recovery:other",
-                plusMenuMode: "full",
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(container.querySelector(".agent-composer-prosemirror")?.textContent).toBe("Seed prompt");
-        expect(harnessRuntime?.thread.composer.getState().attachments).toHaveLength(0);
-        expect(container.querySelector('[data-agent-composer-slot="mode-row"]')).toBeNull();
-    });
-    it("does not restore a stale draft after the composer is cleared", async () => {
-        const scope = "draft-recovery:clear";
-        localStorage.setItem(getComposerDraftKey(scope), "<p>d</p>");
-        const focusRef = React.createRef();
-        function Harness({ initialText }) {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                draftScope: scope,
-                initialText,
-                initialTextKey: "same-draft",
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness, { initialText: "Seed prompt" }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(container.querySelector(".agent-composer-prosemirror")?.textContent).toBe("d");
-        act(() => focusRef.current?.setText(""));
-        expect(container.querySelector(".agent-composer-prosemirror")?.textContent).toBe("");
-        // Model the debounced draft write still holding the final character.
-        localStorage.setItem(getComposerDraftKey(scope), "<p>d</p>");
-        await act(async () => {
-            root.render(React.createElement(Harness, { initialText: "" }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(container.querySelector(".agent-composer-prosemirror")?.textContent).toBe("");
-    });
-    it("moves focus outside Home when its hidden context picker closes", async () => {
-        const contextMenuItems = [
-            {
-                id: "source",
-                label: "Source",
-                picker: {
-                    presentation: {
-                        type: "dialog",
-                        mode: "multiple",
-                        onAttach: vi.fn(),
-                    },
-                    searchPlaceholder: "Search sources",
-                    scopeKey: "account",
-                    load: async () => ({ items: [], hasMore: false }),
-                },
-            },
-        ];
-        function Harness({ disabled }) {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement("button", { id: "visible-page-target" }, "Next"), React.createElement("div", { hidden: disabled }, React.createElement(TiptapComposer, {
-                disabled,
-                contextMenuItems,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                toolbarSlot: React.createElement("button", { type: "button" }, "Model selector"),
-                voiceEnabled: false,
-            }))));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness, { disabled: false }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        const addContext = container.querySelector('button[aria-label="Add context"]');
-        expect(addContext).not.toBeNull();
-        await act(async () => {
-            addContext.focus();
-            addContext.dispatchEvent(new KeyboardEvent("keydown", {
-                key: "ArrowDown",
-                bubbles: true,
-                cancelable: true,
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        const clickMenuItem = async (label) => {
-            const item = Array.from(document.querySelectorAll('[role^="menuitem"]')).find((element) => element.textContent?.trim() === label);
-            expect(item, label).toBeDefined();
-            await act(async () => {
-                item.click();
-                await new Promise((resolve) => setTimeout(resolve, 0));
-            });
-        };
-        await clickMenuItem("Add context");
-        await clickMenuItem("Source");
-        expect(document.querySelector('[role="dialog"]')).not.toBeNull();
-        await act(async () => {
-            root.render(React.createElement(Harness, { disabled: true }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        await act(async () => new Promise((resolve) => window.requestAnimationFrame(() => resolve())));
-        expect(document.querySelector('[role="dialog"]')).toBeNull();
-        expect(document.activeElement).toBe(container.querySelector("#visible-page-target"));
-    });
-    it("syncs identical text after switching draft scopes", async () => {
-        const runs = [];
-        const recordingAdapter = {
-            async *run({ messages }) {
-                runs.push(messages);
-            },
-        };
-        const focusRef = React.createRef();
-        function Harness({ currentScope }) {
-            const runtime = useLocalRuntime(recordingAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                draftScope: currentScope,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        const submit = async () => {
-            const editor = container.querySelector(".agent-composer-prosemirror");
-            await act(async () => {
-                editor.dispatchEvent(new KeyboardEvent("keydown", {
-                    bubbles: true,
-                    cancelable: true,
-                    key: "Enter",
-                }));
-                await new Promise((resolve) => setTimeout(resolve, 0));
-            });
-        };
-        await act(async () => {
-            root.render(React.createElement(Harness, { currentScope: "scope-a" }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => focusRef.current?.setText("hello"));
-        await submit();
-        await act(async () => {
-            root.render(React.createElement(Harness, { currentScope: "scope-b" }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => focusRef.current?.setText("hello"));
-        await submit();
-        expect(runs).toHaveLength(2);
-        expect(runs[1]?.at(-1)?.content).toEqual([{ type: "text", text: "hello" }]);
-    });
-    it("clears the submitted draft after a scope switch without clearing the new draft", async () => {
-        let resolveSubmit;
-        const onSubmit = vi.fn(() => new Promise((resolve) => {
-            resolveSubmit = resolve;
-        }));
-        const focusRef = React.createRef();
-        function Harness({ scope }) {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                draftScope: scope,
-                onSubmit,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness, { scope: "submitted-thread" }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => focusRef.current?.setText("submitted prompt"));
-        await act(async () => {
-            container
-                .querySelector(".agent-composer-prosemirror")
-                .dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(onSubmit).toHaveBeenCalledOnce();
-        expect(localStorage.getItem(getComposerDraftKey("submitted-thread"))).toContain("submitted prompt");
-        await act(async () => {
-            root.render(React.createElement(Harness, { scope: "new-thread" }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => focusRef.current?.setText("new prompt"));
-        await act(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 400));
-        });
-        await act(async () => {
-            resolveSubmit?.();
-            await Promise.resolve();
-        });
-        expect(localStorage.getItem(getComposerDraftKey("submitted-thread"))).toBeNull();
-        expect(localStorage.getItem(getComposerDraftKey("new-thread"))).toContain("new prompt");
-    });
-    it("clears the persisted draft even when the host unmounts the composer before onSubmit resolves", async () => {
-        const scope = "unmount-before-resolve";
-        let resolveSubmit;
-        const onSubmit = vi.fn(() => new Promise((resolve) => {
-            resolveSubmit = resolve;
-        }));
-        const focusRef = React.createRef();
-        const localContainer = document.createElement("div");
-        document.body.appendChild(localContainer);
-        const localRoot = createRoot(localContainer);
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                draftScope: scope,
-                onSubmit,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            localRoot.render(React.createElement(Harness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => focusRef.current?.setText("abandoned prompt"));
-        const editorEl = localContainer.querySelector(".agent-composer-prosemirror");
-        await act(async () => {
-            editorEl.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(onSubmit).toHaveBeenCalledTimes(1);
-        expect(localStorage.getItem(getComposerDraftKey(scope))).toContain("abandoned prompt");
-        act(() => localRoot.unmount());
-        localContainer.remove();
-        await act(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 5));
-        });
-        await act(async () => {
-            resolveSubmit?.();
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        expect(localStorage.getItem(getComposerDraftKey(scope))).toBeNull();
-    });
-    it("does not clear a newer draft when a stale submit from an unmounted, same-scope composer instance finally resolves", async () => {
-        const scope = "reused-scope-after-unmount";
-        let resolveFirstSubmit;
-        const firstSubmit = vi.fn(() => new Promise((resolve) => {
-            resolveFirstSubmit = resolve;
-        }));
-        const firstFocusRef = React.createRef();
-        const firstContainer = document.createElement("div");
-        document.body.appendChild(firstContainer);
-        const firstRoot = createRoot(firstContainer);
-        function FirstHarness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef: firstFocusRef,
-                draftScope: scope,
-                onSubmit: firstSubmit,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            firstRoot.render(React.createElement(FirstHarness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => firstFocusRef.current?.setText("stale prompt"));
-        const firstEditorEl = firstContainer.querySelector(".agent-composer-prosemirror");
-        await act(async () => {
-            firstEditorEl.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(firstSubmit).toHaveBeenCalledTimes(1);
-        expect(localStorage.getItem(getComposerDraftKey(scope))).toContain("stale prompt");
-        act(() => firstRoot.unmount());
-        firstContainer.remove();
-        await act(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 5));
-        });
-        const secondFocusRef = React.createRef();
-        const secondContainer = document.createElement("div");
-        document.body.appendChild(secondContainer);
-        const secondRoot = createRoot(secondContainer);
-        function SecondHarness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef: secondFocusRef,
-                draftScope: scope,
-                onSubmit: vi.fn(() => new Promise(() => { })),
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            secondRoot.render(React.createElement(SecondHarness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => secondFocusRef.current?.setText("fresh prompt"));
-        await act(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 400));
-        });
-        expect(localStorage.getItem(getComposerDraftKey(scope))).toContain("fresh prompt");
-        await act(async () => {
-            resolveFirstSubmit?.();
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        expect(localStorage.getItem(getComposerDraftKey(scope))).toContain("fresh prompt");
-        act(() => secondRoot.unmount());
-        secondContainer.remove();
-        await act(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 5));
-        });
-    });
-    it("waits for old attachment cleanup before accepting a new-scope upload", async () => {
-        let releaseCleanup;
-        const cleanupDone = new Promise((resolve) => {
-            releaseCleanup = resolve;
-        });
-        const removeAttachment = vi.fn(() => cleanupDone);
-        const attachmentAdapter = {
-            accept: "*",
-            add: async ({ file }) => ({
-                id: file.name,
-                type: "document",
-                name: file.name,
-                contentType: file.type,
-                file,
-                status: { type: "requires-action", reason: "composer-send" },
-            }),
-            remove: removeAttachment,
-            send: async (attachment) => ({
-                ...attachment,
-                status: { type: "complete" },
-                content: [],
-            }),
-        };
-        const focusRef = React.createRef();
-        let harnessRuntime;
-        function Harness({ currentScope }) {
-            const runtime = useLocalRuntime(emptyChatModelAdapter, {
-                adapters: { attachments: attachmentAdapter },
-            });
-            harnessRuntime = runtime;
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                draftScope: currentScope,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "upload-only",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness, { currentScope: "scope-a" }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        await act(async () => {
-            await harnessRuntime?.thread.composer.addAttachment(new File(["old"], "same.txt", { type: "text/plain" }));
-        });
-        await act(async () => {
-            root.render(React.createElement(Harness, { currentScope: "scope-b" }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(harnessRuntime?.thread.composer.getState().attachments).toHaveLength(0);
-        const input = container.querySelector('input[type="file"]');
-        expect(input).not.toBeNull();
-        Object.defineProperty(input, "files", {
-            configurable: true,
-            value: [new File(["new"], "same.txt", { type: "text/plain" })],
-        });
-        await act(async () => {
-            input?.dispatchEvent(new Event("change", { bubbles: true }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(removeAttachment).toHaveBeenCalledTimes(1);
-        expect(harnessRuntime?.thread.composer.getState().attachments).toHaveLength(0);
-        await act(async () => {
-            releaseCleanup();
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(harnessRuntime?.thread.composer.getState().attachments).toHaveLength(1);
-    });
-    it.each([
-        [
-            "text",
-            {
-                type: "text",
-                text: "PK",
-                backgroundColor: "#4f46e5",
-            },
-        ],
-        [
-            "image",
-            {
-                type: "image",
-                src: "/agents/property.png",
-                fit: "cover",
-                backgroundColor: "#ffffff",
-            },
-        ],
-        ["none", { type: "none" }],
-    ])("preserves %s mention media through HTML drafts", (_type, media) => {
-        const first = new Editor({
-            element: document.createElement("div"),
-            extensions: createTiptapComposerExtensions(() => "Message agent..."),
-            content: {
-                type: "doc",
-                content: [
-                    {
-                        type: "paragraph",
-                        content: [
-                            {
-                                type: "mentionReference",
-                                attrs: {
-                                    label: "Property agent",
-                                    media,
-                                },
-                            },
-                        ],
-                    },
-                ],
-            },
-        });
-        const html = first.getHTML();
-        first.destroy();
-        expect(html).toContain("data-media=");
-        expect(html).not.toContain("[object Object]");
-        const restored = new Editor({
-            element: document.createElement("div"),
-            extensions: createTiptapComposerExtensions(() => "Message agent..."),
-            content: html,
-        });
-        const mentionNode = restored.getJSON().content?.[0]?.content?.[0];
-        restored.destroy();
-        expect(mentionNode?.attrs?.media).toEqual(media);
-    });
-    it("allows sending an attachment-only prompt", () => {
-        expect(canSubmitComposerContent({
-            hasEditorContent: false,
-            attachmentCount: 1,
-        })).toBe(true);
-        expect(canSubmitComposerContent({
-            hasEditorContent: false,
-            attachmentCount: 1,
-            disabled: true,
-        })).toBe(false);
-    });
-    it("uses one primary action while a response is running", () => {
-        expect(resolveComposerPrimaryAction({
-            canSubmit: false,
-            hasStopButton: true,
-        })).toBe("stop");
-        expect(resolveComposerPrimaryAction({
-            canSubmit: true,
-            hasStopButton: true,
-        })).toBe("send");
-        expect(resolveComposerPrimaryAction({
-            canSubmit: false,
-            hasStopButton: false,
-        })).toBe("send");
-    });
-    it("uses the queue tooltip when the submit will wait", () => {
-        expect(getComposerSendTooltipKey(true)).toBe("composer.queueMessage");
-        expect(getComposerSendTooltipKey(false)).toBe("composer.sendMessage");
-    });
-    it("selects and removes context chips one Backspace at a time", () => {
-        let contextItemKeys = ["dashboard", "panel"];
-        let selectedKey = null;
-        const selectPanel = resolveContextChipBackspaceAction({
-            contextItemKeys,
-            selectedKey,
-            cursorAtStart: true,
-        });
-        expect(selectPanel).toEqual({ type: "select", key: "panel" });
-        selectedKey = selectPanel?.key ?? null;
-        const removePanel = resolveContextChipBackspaceAction({
-            contextItemKeys,
-            selectedKey,
-            cursorAtStart: true,
-        });
-        expect(removePanel).toEqual({ type: "remove", key: "panel" });
-        contextItemKeys = contextItemKeys.filter((key) => key !== removePanel?.key);
-        selectedKey = null;
-        const selectDashboard = resolveContextChipBackspaceAction({
-            contextItemKeys,
-            selectedKey,
-            cursorAtStart: true,
-        });
-        expect(selectDashboard).toEqual({ type: "select", key: "dashboard" });
-        selectedKey = selectDashboard?.key ?? null;
-        expect(resolveContextChipBackspaceAction({
-            contextItemKeys,
-            selectedKey,
-            cursorAtStart: true,
-        })).toEqual({ type: "remove", key: "dashboard" });
-    });
-    it("leaves context chips alone when the caret is not at the start", () => {
-        expect(resolveContextChipBackspaceAction({
-            contextItemKeys: ["dashboard"],
-            selectedKey: null,
-            cursorAtStart: false,
-        })).toBeNull();
-    });
-    it("uses a visible fallback for attachment-only composer mode prompts", () => {
-        expect(displayableComposerModeMessage({
-            messagePrefix: "Create an extension: ",
-            trimmedText: "",
-            attachmentCount: 1,
-        })).toBe("Create an extension: Use the attached context.");
-        expect(displayableComposerModeMessage({
-            messagePrefix: "Erstelle eine Erweiterung: ",
-            trimmedText: "",
-            attachmentCount: 1,
-            attachedContextFallback: "Verwende den angehängten Kontext.",
-        })).toBe("Erstelle eine Erweiterung: Verwende den angehängten Kontext.");
-    });
-    it("detects oversized PDF attachments before submit", () => {
-        const file = new File([new Uint8Array(4 * 1024 * 1024 + 1)], "large.pdf", {
-            type: "application/pdf",
-        });
-        expect(getOversizedDocumentAttachmentError([
-            {
-                type: "document",
-                name: "large.pdf",
-                contentType: "application/pdf",
-                file,
-            },
-        ])).toContain('"large.pdf" is 4.0 MB. PDFs are capped at 4 MB');
-        expect(getOversizedDocumentAttachmentError([
-            {
-                type: "image",
-                name: "large.png",
-                contentType: "image/png",
-                file,
-            },
-        ])).toBeNull();
-    });
-    it("formats fractional document attachment limits", () => {
-        const file = new File([new Uint8Array(2.6 * 1024 * 1024)], "large.pdf", {
-            type: "application/pdf",
-        });
-        expect(getOversizedDocumentAttachmentError([{ type: "document", name: file.name, contentType: file.type, file }], { maxBytes: 2.5 * 1024 * 1024 })).toContain("PDFs are capped at 2.5 MB");
-    });
-    it("allows hosts to use a larger multipart document cap", () => {
-        const file = new File([new Uint8Array(4 * 1024 * 1024 + 1)], "reference.pdf", { type: "application/pdf" });
-        expect(getOversizedDocumentAttachmentError([
-            {
-                type: "document",
-                name: "reference.pdf",
-                contentType: "application/pdf",
-                file,
-            },
-        ], {
-            maxBytes: 50 * 1024 * 1024,
-            label: "Slides reference files",
-        })).toBeNull();
-    });
-    it("localizes a custom multipart document cap", () => {
-        const file = new File([new Uint8Array(4 * 1024 * 1024 + 1)], "reference.pdf", { type: "application/pdf" });
-        let translatedOptions;
-        const error = getOversizedDocumentAttachmentError([
-            {
-                type: "document",
-                name: "reference.pdf",
-                contentType: "application/pdf",
-                file,
-            },
-        ], {
-            maxBytes: 4 * 1024 * 1024,
-            label: "Präsentationsdateien",
-            translate: (key, options) => {
-                expect(key).toBe("agentChat.composer.documentTooLarge");
-                translatedOptions = options;
-                return `„${String(options?.name)}“ ist ${String(options?.size)} MB groß. ${String(options?.label)} sind auf ${String(options?.maxSize)} MB begrenzt.`;
-            },
-        });
-        expect(error).toBe("„reference.pdf“ ist 4.0 MB groß. Präsentationsdateien sind auf 4 MB begrenzt.");
-        expect(translatedOptions).toEqual(expect.objectContaining({
-            name: "reference.pdf",
-            size: "4.0",
-            label: "Präsentationsdateien",
-            maxSize: "4",
-        }));
-    });
-    it("maps Enter keybindings to immediate and queued submit intents", () => {
-        const enter = {
-            key: "Enter",
-            shiftKey: false,
-            metaKey: false,
-            ctrlKey: false,
-        };
-        expect(getComposerSubmitIntentForEnterKey(enter, true)).toBe("immediate");
-        expect(getComposerSubmitIntentForEnterKey(enter, false)).toBe("immediate");
-        expect(getComposerSubmitIntentForEnterKey({ ...enter, metaKey: true }, true)).toBe("queued");
-        expect(getComposerSubmitIntentForEnterKey({ ...enter, ctrlKey: true }, false)).toBe("queued");
-        expect(getComposerSubmitIntentForEnterKey({ ...enter, shiftKey: true, metaKey: true }, true)).toBeNull();
-        expect(getComposerSubmitIntentForEnterKey({ ...enter, ctrlKey: true }, true)).toBeNull();
-        expect(getComposerSubmitIntentForEnterKey({ ...enter, metaKey: true }, false)).toBeNull();
-    });
-    it("scrolls the composer caret into view for Shift+Enter line breaks", () => {
-        const editor = new Editor({
-            element: document.createElement("div"),
-            extensions: createTiptapComposerExtensions(() => "Message agent..."),
-            content: "<p>Hello</p>",
-        });
-        editor.commands.setTextSelection(editor.state.doc.content.size);
-        const view = editor.view;
-        const scrolledTransactions = [];
-        const dispatch = view.dispatch.bind(view);
-        view.dispatch = (transaction) => {
-            scrolledTransactions.push(transaction.scrolledIntoView);
-            dispatch(transaction);
-        };
-        expect(insertComposerHardBreakAndScrollIntoView(view)).toBe(true);
-        expect(scrolledTransactions).toEqual([true]);
-        expect(editor.getText()).toBe("Hello\n");
-        editor.destroy();
-    });
-    it("guards popover positioning when the editor cannot resolve coordinates", () => {
-        expect(getComposerPopoverPosition({
-            coordsAtPos: () => ({ top: 12, bottom: 20, left: 34, right: 34 }),
-        }, 1)).toEqual({ top: 12, left: 34 });
-        expect(getComposerPopoverPosition({
-            coordsAtPos: () => {
-                throw new TypeError("node.getBoundingClientRect is not a function");
-            },
-        }, 1)).toBeNull();
-        expect(getComposerPopoverPosition({
-            coordsAtPos: () => ({
-                top: Number.NaN,
-                bottom: 20,
-                left: 34,
-                right: 34,
-            }),
-        }, 1)).toBeNull();
-    });
-    it("anchors the composer popover to the composer root", () => {
-        const root = document.createElement("div");
-        root.setAttribute("data-agent-composer-slot", "root");
-        const editor = document.createElement("div");
-        root.appendChild(editor);
-        document.body.appendChild(root);
-        vi.spyOn(root, "getBoundingClientRect").mockReturnValue({
-            top: 180,
-            left: 24,
-            width: 640,
-            right: 664,
-            bottom: 260,
-            height: 80,
-            x: 24,
-            y: 180,
-            toJSON: () => { },
-        });
-        expect(getComposerPopoverAnchorPosition({
-            coordsAtPos: () => ({
-                top: 224,
-                bottom: 244,
-                left: 96,
-                right: 96,
-            }),
-            dom: editor,
-        }, 1)).toEqual({ top: 180, left: 24, width: 640 });
-        root.remove();
-    });
-    it("consumes composer file drops so parent drop targets do not attach duplicates", () => {
-        const file = new File(["fake"], "image.png", { type: "image/png" });
-        const added = [];
-        let prevented = false;
-        let stopped = false;
-        const handled = handleComposerFileDrop({
-            event: {
-                dataTransfer: { files: [file] },
-                preventDefault: () => {
-                    prevented = true;
-                },
-                stopPropagation: () => {
-                    stopped = true;
-                },
-            },
-            addAttachment: async (attachment) => {
-                added.push(attachment);
-            },
-        });
-        expect(handled).toBe(true);
-        expect(prevented).toBe(true);
-        expect(stopped).toBe(true);
-        expect(added).toHaveLength(1);
-        expect(added[0]?.name).toMatch(/^\d+-[a-z0-9]+-image\.png$/);
-    });
-    it("consumes but does not attach file drops while uploads are disabled", () => {
-        const file = new File(["fake"], "image.png", { type: "image/png" });
-        const added = vi.fn();
-        let prevented = false;
-        let stopped = false;
-        const handled = handleComposerFileDrop({
-            event: {
-                dataTransfer: { files: [file] },
-                preventDefault: () => {
-                    prevented = true;
-                },
-                stopPropagation: () => {
-                    stopped = true;
-                },
-            },
-            addAttachment: added,
-            attachmentsEnabled: false,
-        });
-        expect(handled).toBe(true);
-        expect(prevented).toBe(true);
-        expect(stopped).toBe(true);
-        expect(added).not.toHaveBeenCalled();
-    });
-    it("reports the filename of a rejected dropped attachment", async () => {
-        const file = new File(["fake"], "unsupported.xlsm", {
-            type: "application/vnd.ms-excel.sheet.macroEnabled.12",
-        });
-        const onError = vi.fn();
-        handleComposerFileDrop({
-            event: {
-                dataTransfer: { files: [file] },
-                preventDefault: () => { },
-                stopPropagation: () => { },
-            },
-            addAttachment: async () => {
-                throw new Error("File type .xlsm is not accepted.");
-            },
-            onError,
-        });
-        await vi.waitFor(() => {
-            expect(onError).toHaveBeenCalledWith(expect.objectContaining({
-                message: "File type .xlsm is not accepted.",
-            }), "unsupported.xlsm");
-        });
-    });
-    it("caps the model picker height without forcing empty vertical space", () => {
-        expect(MODEL_SELECTOR_POPOVER_STYLE).toMatchObject({
-            fontSize: 13,
-            maxHeight: "min(500px, var(--radix-popover-content-available-height, 500px))",
-        });
-        expect(MODEL_SELECTOR_POPOVER_STYLE).not.toHaveProperty("height");
-    });
-    it("shows the model picker skeleton only while the initial list is loading", () => {
-        expect(shouldShowModelSelectorSkeleton(true, 0)).toBe(true);
-        expect(shouldShowModelSelectorSkeleton(true, 2)).toBe(false);
-        expect(shouldShowModelSelectorSkeleton(false, 0)).toBe(false);
-    });
-    it("replaces the model list with connect CTAs only when nothing is configured", () => {
-        const unconfigured = [{ configured: false }, { configured: false }];
-        expect(shouldShowOnlyConnectPath(true, unconfigured)).toBe(true);
-        expect(shouldShowOnlyConnectPath(true, [
-            { configured: true },
-            { configured: false },
-        ])).toBe(false);
-        expect(shouldShowOnlyConnectPath(false, unconfigured)).toBe(false);
-    });
-    it("keeps cloud setup readiness separate from local runtime readiness", () => {
-        expect(hasConfiguredCloudProvider([
-            { engine: "pi-cli", configured: true },
-            { engine: "opencode-cli", configured: true },
-        ])).toBe(false);
-        expect(hasConfiguredCloudProvider([
-            { engine: "pi-cli", configured: true },
-            { engine: "builder", configured: true },
-        ])).toBe(true);
-        expect(hasConfiguredCloudProvider([{ engine: "builder", configured: false }])).toBe(false);
-    });
-    it("still renders the picker when nothing is configured, even though that leaves selectedModel empty", () => {
-        const unconfigured = [
-            {
-                engine: "openai",
-                label: "OpenAI",
-                models: ["gpt-5"],
-                configured: false,
-            },
-        ];
-        expect(shouldRenderModelSelector(unconfigured, () => { })).toBe(true);
-        expect(shouldRenderModelSelector([], () => { })).toBe(true);
-        expect(shouldRenderModelSelector(unconfigured, undefined)).toBe(false);
-        expect(shouldRenderModelSelector(undefined, () => { })).toBe(false);
-    });
-    it("shows short selected names and full versioned model names", () => {
-        function Harness({ configured }) {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                availableModels: [
-                    {
-                        engine: "openai",
-                        label: "OpenAI",
-                        models: ["gpt-5.6-luna"],
-                        configured,
-                    },
-                ],
-                selectedModel: "gpt-5.6-luna",
-                selectedEngine: "openai",
-                onModelChange: vi.fn(),
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                providerConnectStatusEnabled: false,
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness, { configured: false })));
-        const modelButton = container.querySelector('[data-agent-composer-slot="model-button"]');
-        expect(modelButton?.textContent).toContain("Connect keys");
-        expect(modelButton?.textContent).not.toContain("GPT-5.6 Luna");
-        expect(modelButton?.getAttribute("aria-label")).toContain("Connect keys");
-        expect(modelButton?.getAttribute("aria-label")).not.toContain("GPT-5.6 Luna");
-        act(() => modelButton?.click());
-        const modelTab = Array.from(document.querySelectorAll('[role="tab"]')).find((tab) => tab.textContent?.includes("Connect keys"));
-        expect(modelTab?.textContent).toContain("Connect keys");
-        act(() => modelButton?.click());
-        act(() => root.render(React.createElement(Harness, { configured: true })));
-        expect(container.querySelector('[data-agent-composer-slot="model-button"]')
-            ?.textContent).toContain("Luna");
-        expect(container.querySelector('[data-agent-composer-slot="model-button"]')
-            ?.textContent).not.toContain("GPT-5.6 Luna");
-        expect(container
-            .querySelector('[data-agent-composer-slot="model-button"]')
-            ?.getAttribute("aria-label")).toContain("GPT-5.6 Luna");
-        act(() => container
-            .querySelector('[data-agent-composer-slot="model-button"]')
-            ?.click());
-        const picker = document.querySelector('[data-agent-native-composer-popover="true"]');
-        expect(picker?.textContent).toContain("GPT-5.6 Luna");
-    });
-    it("shows current Builder model versions in the picker", () => {
-        const models = [
-            "gpt-6-sol",
-            "gpt-6-luna",
-            "claude-opus-5-5",
-            "gemini-3-8-flash",
-        ];
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                availableModels: [
-                    {
-                        engine: "builder",
-                        label: "Builder.io Gateway",
-                        models,
-                        configured: true,
-                    },
-                ],
-                selectedModel: "gpt-6-luna",
-                selectedEngine: "builder",
-                onModelChange: vi.fn(),
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                providerConnectStatusEnabled: false,
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness)));
-        const modelButton = container.querySelector('[data-agent-composer-slot="model-button"]');
-        expect(modelButton?.textContent).toContain("Luna");
-        expect(modelButton?.textContent).not.toContain("GPT-6 Luna");
-        expect(modelButton?.getAttribute("aria-label")).toContain("GPT-6 Luna");
-        act(() => modelButton?.click());
-        const modelTab = Array.from(document.querySelectorAll('[role="tab"]')).find((tab) => tab.textContent?.includes("Model"));
-        act(() => modelTab?.click());
-        const picker = document.querySelector('[role="tabpanel"][aria-label="model"]');
-        expect(picker?.textContent).toContain("GPT-6 Sol");
-        expect(picker?.textContent).toContain("GPT-6 Luna");
-        expect(picker?.textContent).toContain("Claude Opus 5.5");
-        expect(picker?.textContent).toContain("Gemini 3.8 Flash");
-    });
-    it("chooses the newest tier version regardless of catalog order", () => {
-        const models = [
-            "openai/gpt-5.6-sol",
-            "openai/gpt-6-sol",
-            "anthropic/claude-opus-4.8",
-            "anthropic/claude-opus-5.5",
-            "google/gemini-2.5-flash",
-            "google/gemini-3.8-flash",
-        ];
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                availableModels: [
-                    {
-                        engine: "ai-sdk:openrouter",
-                        label: "OpenRouter",
-                        models,
-                        configured: true,
-                    },
-                ],
-                selectedModel: "google/gemini-3.8-flash",
-                selectedEngine: "ai-sdk:openrouter",
-                onModelChange: vi.fn(),
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                providerConnectStatusEnabled: false,
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness)));
-        const modelButton = container.querySelector('[data-agent-composer-slot="model-button"]');
-        expect(modelButton?.textContent).toContain("Flash");
-        expect(modelButton?.textContent).not.toContain("Gemini 3.8 Flash");
-        act(() => modelButton?.click());
-        const modelTab = Array.from(document.querySelectorAll('[role="tab"]')).find((tab) => tab.textContent?.includes("Model"));
-        act(() => modelTab?.click());
-        const picker = document.querySelector('[role="tabpanel"][aria-label="model"]');
-        expect(picker?.textContent).toContain("GPT-6 Sol");
-        expect(picker?.textContent).toContain("Claude Opus 5.5");
-        expect(picker?.textContent).toContain("Gemini 3.8 Flash");
-        expect(picker?.textContent).not.toContain("GPT-5.6 Sol");
-        expect(picker?.textContent).not.toContain("Claude Opus 4.8");
-        expect(picker?.textContent).not.toContain("Gemini 2.5 Flash");
-    });
-    it("resets a hidden model when switching to Claude Code", async () => {
-        const onModelChange = vi.fn();
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                availableModels: [
-                    {
-                        engine: "openai",
-                        label: "OpenAI",
-                        models: ["gpt-5.6-sol"],
-                        configured: true,
-                    },
-                    {
-                        engine: "claude-cli",
-                        label: "Claude Code",
-                        models: ["claude-sonnet-5"],
-                        configured: true,
-                    },
-                ],
-                selectedModel: "gpt-5.6-sol",
-                selectedEngine: "openai",
-                selectedAgent: "claude-code",
-                onModelChange,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness)));
-        await act(async () => { });
-        expect(onModelChange).toHaveBeenCalledWith("claude-sonnet-5", "claude-cli");
-    });
-});
-describe("TiptapComposer storage gate", () => {
-    it("opens storage setup from Upload File without exposing a file picker", async () => {
-        const onAttachmentRequest = vi.fn();
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                attachmentsEnabled: false,
-                onAttachmentRequest,
-                plusMenuMode: "upload-only",
-                includeDefaultSlashSkills: false,
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(container.querySelector('input[type="file"]')).toBeNull();
-        const plusButton = container.querySelector('button[aria-label="Add context"]');
-        expect(plusButton).not.toBeNull();
-        await act(async () => {
-            plusButton?.dispatchEvent(new MouseEvent("pointerdown", { bubbles: true, button: 0 }));
-            plusButton?.dispatchEvent(new MouseEvent("pointerup", { bubbles: true, button: 0 }));
-            plusButton?.click();
-        });
-        const uploadItem = Array.from(document.querySelectorAll("[role=menuitem]")).at(0);
-        expect(uploadItem).toBeDefined();
-        await act(async () => uploadItem?.click());
-        expect(onAttachmentRequest).toHaveBeenCalledOnce();
-        expect(container.querySelector('input[type="file"]')).toBeNull();
-    });
-});
-describe("TiptapComposer paste handling", () => {
-    it("keeps text from a mixed text and image paste when uploads are disabled", async () => {
-        const pastedText = "Keep this text";
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                attachmentsEnabled: false,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                providerConnectStatusEnabled: false,
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        expect(editor).not.toBeNull();
-        const clipboardData = {
-            files: [new File(["image"], "image.png", { type: "image/png" })],
-            getData: (type) => (type === "text/plain" ? pastedText : ""),
-        };
-        const pasteEvent = new Event("paste", {
-            bubbles: true,
-            cancelable: true,
-        });
-        Object.defineProperty(pasteEvent, "clipboardData", {
-            value: clipboardData,
-        });
-        await act(async () => {
-            editor?.dispatchEvent(pasteEvent);
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(editor?.textContent).toBe(pastedText);
-        expect(pasteEvent.defaultPrevented).toBe(true);
-    });
-    it("keeps large plain-text pastes in the composer when uploads are disabled", async () => {
-        const pastedText = "A".repeat(3200);
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                attachmentsEnabled: false,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                providerConnectStatusEnabled: false,
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        expect(editor).not.toBeNull();
-        const clipboardData = {
-            files: [],
-            getData: (type) => (type === "text/plain" ? pastedText : ""),
-        };
-        const pasteEvent = new Event("paste", {
-            bubbles: true,
-            cancelable: true,
-        });
-        Object.defineProperty(pasteEvent, "clipboardData", {
-            value: clipboardData,
-        });
-        await act(async () => {
-            editor?.dispatchEvent(pasteEvent);
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(editor?.textContent).toBe(pastedText);
-    });
-});
-describe("TiptapComposer references", () => {
-    it("reports slot reference insertions and removals to the host", async () => {
-        const onReferencesChange = vi.fn();
-        const focusRef = React.createRef();
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                onReferencesChange,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        onReferencesChange.mockClear();
-        await act(async () => {
-            focusRef.current?.insertReference({
-                label: "Document",
-                refType: "file",
-                refId: "document-reference",
-                slotKey: "document",
-            });
-        });
-        expect(onReferencesChange).toHaveBeenLastCalledWith([
-            expect.objectContaining({
-                type: "file",
-                name: "Document",
-                refId: "document-reference",
-                slotKey: "document",
-            }),
-        ]);
-        const removeButton = container.querySelector('[data-agent-composer-slot="context-row"] button');
-        expect(removeButton).not.toBeNull();
-        await act(async () => removeButton.click());
-        expect(onReferencesChange).toHaveBeenLastCalledWith([]);
-    });
-});
-describe("TiptapComposer slash commands", () => {
-    it("locks submission without blurring the editable surface", () => {
-        const focusRef = React.createRef();
-        function Harness({ submitting }) {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                submitting,
-                onSubmit: vi.fn(),
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness, { submitting: false })));
-        act(() => focusRef.current?.setText("Queue the next instruction"));
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        editor.focus();
-        act(() => root.render(React.createElement(Harness, { submitting: true })));
-        expect(editor.getAttribute("contenteditable")).toBe("true");
-        expect(document.activeElement).toBe(editor);
-        const sendButton = container.querySelector('[data-agent-composer-slot="send-button"]');
-        expect(sendButton?.disabled).toBe(true);
-        expect(sendButton?.getAttribute("aria-label")).toMatch(/loading/i);
-        expect(sendButton?.getAttribute("aria-label")).not.toMatch(/checking/i);
-    });
-    it("keeps the editor focused after a successful submission", async () => {
-        const onSubmit = vi.fn(async () => undefined);
-        const focusRef = React.createRef();
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                onSubmit,
-                placeholder: "Ask the agent...",
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness)));
-        act(() => focusRef.current?.setText("Continue the review"));
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        await act(async () => {
-            editor.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-        });
-        expect(onSubmit).toHaveBeenCalled();
-        expect(editor.textContent).toBe("");
-        expect(document.activeElement).toBe(editor);
-        const emptyParagraph = editor.querySelector("p.is-empty:first-child:last-child");
-        expect(emptyParagraph?.getAttribute("data-placeholder")).toBe("Ask the agent...");
-        expect(Array.from(container.querySelectorAll("style")).some((style) => style.textContent?.includes("p.is-empty:first-child:last-child::before"))).toBe(true);
-    });
-    it("submits a slash-prefixed prompt when no command handler is provided", async () => {
-        const onSubmit = vi.fn();
-        const focusRef = React.createRef();
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                ariaLabel: "Message release agent",
-                onSubmit,
-                clearOnSubmit: false,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness)));
-        act(() => focusRef.current?.setText("/act"));
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        expect(editor.getAttribute("role")).toBe("textbox");
-        expect(editor.getAttribute("aria-label")).toBe("Message release agent");
-        expect(editor.getAttribute("aria-multiline")).toBe("true");
-        await act(async () => {
-            editor.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-        });
-        expect(onSubmit).toHaveBeenCalledWith("/act", [], [], expect.objectContaining({ intent: "immediate" }));
-        expect(editor.textContent).toBe("/act");
-    });
-    it("ignores duplicate submits while a host submission is pending", async () => {
-        let resolveSubmit;
-        const onSubmit = vi.fn(() => new Promise((resolve) => {
-            resolveSubmit = resolve;
-        }));
-        const focusRef = React.createRef();
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                onSubmit,
-                clearOnSubmit: false,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness)));
-        act(() => focusRef.current?.setText("send this once"));
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        await act(async () => {
-            const event = new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            });
-            editor.dispatchEvent(event);
-            editor.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-            await Promise.resolve();
-        });
-        expect(onSubmit).toHaveBeenCalledOnce();
-        resolveSubmit();
-        await act(async () => { });
-    });
-    it("keeps submission locked until status-updated attachments are removed", async () => {
-        let resolveStatusUpdate;
-        const statusUpdate = new Promise((resolve) => {
-            resolveStatusUpdate = resolve;
-        });
-        let finishUpload;
-        const uploadFinished = new Promise((resolve) => {
-            finishUpload = resolve;
-        });
-        let resolveRemoval;
-        const removal = new Promise((resolve) => {
-            resolveRemoval = resolve;
-        });
-        const removeAttachment = vi.fn(() => removal);
-        const attachmentAdapter = {
-            accept: "*",
-            add: async function* ({ file }) {
-                const attachment = {
-                    id: file.name,
-                    type: "document",
-                    name: file.name,
-                    contentType: file.type,
-                    file,
-                    status: {
-                        type: "running",
-                        reason: "uploading",
-                        progress: 0,
-                    },
-                };
-                yield attachment;
-                await statusUpdate;
-                yield {
-                    ...attachment,
-                    status: { type: "requires-action", reason: "composer-send" },
-                };
-                finishUpload();
-            },
-            remove: removeAttachment,
-            send: async (attachment) => ({
-                ...attachment,
-                status: { type: "complete" },
-                content: [],
-            }),
-        };
-        let resolveSubmit;
-        const submission = new Promise((resolve) => {
-            resolveSubmit = resolve;
-        });
-        const onSubmit = vi.fn(() => submission);
-        const focusRef = React.createRef();
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter, {
-                adapters: { attachments: attachmentAdapter },
-            });
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                onSubmit,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "upload-only",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => focusRef.current?.setText("send this once"));
-        const fileInput = container.querySelector('input[type="file"]');
-        Object.defineProperty(fileInput, "files", {
-            configurable: true,
-            value: [new File(["once"], "once.txt", { type: "text/plain" })],
-        });
-        await act(async () => {
-            fileInput.dispatchEvent(new Event("change", { bubbles: true }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        const submit = () => editor.dispatchEvent(new KeyboardEvent("keydown", {
-            bubbles: true,
-            cancelable: true,
-            key: "Enter",
-        }));
-        await act(async () => {
-            submit();
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(onSubmit).toHaveBeenCalledOnce();
-        expect(removeAttachment).not.toHaveBeenCalled();
-        resolveStatusUpdate();
-        await act(async () => {
-            await uploadFinished;
-            resolveSubmit();
-            await submission;
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(removeAttachment).toHaveBeenCalledOnce();
-        expect(removeAttachment).toHaveBeenCalledWith(expect.objectContaining({
-            status: { type: "requires-action", reason: "composer-send" },
-        }));
-        await act(async () => {
-            submit();
-            await Promise.resolve();
-        });
-        expect(onSubmit).toHaveBeenCalledOnce();
-        await act(async () => {
-            resolveRemoval();
-            await removal;
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(editor.textContent).toBe("");
-        act(() => focusRef.current?.setText("next message"));
-        await act(async () => {
-            submit();
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(onSubmit).toHaveBeenCalledTimes(2);
-        expect(onSubmit.mock.calls[1][0]).toBe("next message");
-        expect(onSubmit.mock.calls[1][2]).toEqual([]);
-    });
-    it("reports attachment cleanup failure after a successful submit", async () => {
-        let failRemoval = true;
-        const removeAttachment = vi.fn(async () => {
-            if (failRemoval)
-                throw new Error("storage unavailable");
-        });
-        const attachmentAdapter = {
-            accept: "*",
-            add: async ({ file }) => ({
-                id: file.name,
-                type: "document",
-                name: file.name,
-                contentType: file.type,
-                file,
-                status: { type: "requires-action", reason: "composer-send" },
-            }),
-            remove: removeAttachment,
-            send: async (attachment) => ({
-                ...attachment,
-                status: { type: "complete" },
-                content: [],
-            }),
-        };
-        const onSubmit = vi.fn();
-        const focusRef = React.createRef();
-        let localRuntime;
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter, {
-                adapters: { attachments: attachmentAdapter },
-            });
-            localRuntime = runtime;
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                onSubmit,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "upload-only",
-                voiceEnabled: false,
-            })));
-        }
-        await act(async () => {
-            root.render(React.createElement(Harness));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        act(() => focusRef.current?.setText("send this once"));
-        const fileInput = container.querySelector('input[type="file"]');
-        Object.defineProperty(fileInput, "files", {
-            configurable: true,
-            value: [new File(["once"], "once.txt", { type: "text/plain" })],
-        });
-        await act(async () => {
-            fileInput.dispatchEvent(new Event("change", { bubbles: true }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        await act(async () => {
-            editor.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(onSubmit).toHaveBeenCalledOnce();
-        expect(removeAttachment).toHaveBeenCalledOnce();
-        expect(container.querySelector('[role="alert"]')?.textContent).toBe("The message was sent, but some attachments remain. Remove them before sending again.");
-        expect(editor.textContent).toBe("");
-        expect(localRuntime.thread.composer.getState().attachments).toHaveLength(1);
-        const sendButton = container.querySelector('button[aria-label="Send message"]');
-        expect(sendButton.disabled).toBe(true);
-        act(() => focusRef.current?.setText("retry after cleanup failure"));
-        await act(async () => {
-            editor.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(onSubmit).toHaveBeenCalledOnce();
-        expect(container.querySelector('[role="alert"]')?.textContent).toBe("The message was sent, but some attachments remain. Remove them before sending again.");
-        failRemoval = false;
-        await act(async () => {
-            await localRuntime.thread.composer.getAttachmentByIndex(0).remove();
-        });
-        expect(localRuntime.thread.composer.getState().attachments).toHaveLength(0);
-        expect(sendButton.disabled).toBe(false);
-        expect(container.querySelector('[role="alert"]')).toBeNull();
-        await act(async () => {
-            editor.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        });
-        expect(onSubmit).toHaveBeenCalledTimes(2);
-        expect(onSubmit.mock.calls[1][0]).toBe("retry after cleanup failure");
-        expect(onSubmit.mock.calls[1][2]).toEqual([]);
-    });
-    it("acknowledges an executed slash command", async () => {
-        const onSlashCommand = vi.fn();
-        const focusRef = React.createRef();
-        function Harness() {
-            const runtime = useLocalRuntime(emptyChatModelAdapter);
-            return React.createElement(AssistantRuntimeProvider, { runtime }, React.createElement(TooltipProvider, null, React.createElement(TiptapComposer, {
-                focusRef,
-                onSlashCommand,
-                includeDefaultSlashSkills: false,
-                plusMenuMode: "hidden",
-                voiceEnabled: false,
-            })));
-        }
-        act(() => root.render(React.createElement(Harness)));
-        act(() => focusRef.current?.setText("/act"));
-        const editor = container.querySelector(".agent-composer-prosemirror");
-        await act(async () => {
-            editor.dispatchEvent(new KeyboardEvent("keydown", {
-                bubbles: true,
-                cancelable: true,
-                key: "Enter",
-            }));
-        });
-        expect(onSlashCommand).toHaveBeenCalledWith("act");
-        expect(toast.success).toHaveBeenCalledWith("/act", expect.objectContaining({
-            description: "Switch back to acting",
-            duration: 1800,
-        }));
-    });
-});
-describe("mentionItemMatchesQuery", () => {
-    const sonnet = {
-        id: "ai:anthropic:claude-sonnet-5",
-        label: "Claude Sonnet 5",
-        description: "Anthropic",
-        aliases: ["Sonnet"],
-        source: "content",
-        refType: "content-comment-ai-recipient",
-    };
-    it("matches every host item while the query is empty", () => {
-        expect(mentionItemMatchesQuery(sonnet, "")).toBe(true);
-        expect(mentionItemMatchesQuery(sonnet, "  ")).toBe(true);
-    });
-    it("matches label, alias, and description text case-insensitively", () => {
-        expect(mentionItemMatchesQuery(sonnet, "sonn")).toBe(true);
-        expect(mentionItemMatchesQuery(sonnet, "Claude S")).toBe(true);
-        expect(mentionItemMatchesQuery(sonnet, "anthropic")).toBe(true);
-        expect(mentionItemMatchesQuery(sonnet, "opus")).toBe(false);
-    });
-});
-describe("composerModelCostTier", () => {
-    it("tiers each provider's entry, mid, and flagship models", () => {
-        expect(composerModelCostTier("gpt-5-6-luna")).toBe(1);
-        expect(composerModelCostTier("gpt-5.6-terra")).toBe(2);
-        expect(composerModelCostTier("openai/gpt-5.6-sol")).toBe(3);
-        expect(composerModelCostTier("gpt-6-luna")).toBe(1);
-        expect(composerModelCostTier("openai/gpt-6-sol")).toBe(3);
-        expect(composerModelCostTier("claude-haiku-4-5")).toBe(1);
-        expect(composerModelCostTier("claude-sonnet-5")).toBe(2);
-        expect(composerModelCostTier("anthropic/claude-opus-4.8")).toBe(3);
-        expect(composerModelCostTier("claude-opus-5-5")).toBe(3);
-        expect(composerModelCostTier("claude-fable-5")).toBe(3);
-        expect(composerModelCostTier("gemini-3-1-flash-lite")).toBe(1);
-        expect(composerModelCostTier("gemini-3-1-pro")).toBe(3);
-    });
-    it("returns undefined for unmapped models so no cost label renders", () => {
-        expect(composerModelCostTier("auto")).toBeUndefined();
-        expect(composerModelCostTier("z-ai/glm-5.2")).toBeUndefined();
-        expect(composerModelCostTier("kimi-k2-5")).toBeUndefined();
-        expect(composerModelCostTier("")).toBeUndefined();
-    });
-});
-describe("voice composer insertion", () => {
-    it("adds sentence punctuation and a trailing separator to dictated text", () => {
-        expect(formatVoiceTranscriptForComposer("  First sentence  ")).toBe("First sentence. ");
-        expect(formatVoiceTranscriptForComposer("Already done? ")).toBe("Already done? ");
-        expect(formatVoiceTranscriptForComposer("   ")).toBe("");
-    });
-    it("only removes a live preview when its range still contains the preview", () => {
-        expect(canRemoveVoicePreview({
-            documentSize: 20,
-            anchor: 4,
-            previewText: "draft",
-            currentText: "draft",
-        })).toBe(true);
-        expect(canRemoveVoicePreview({
-            documentSize: 6,
-            anchor: 4,
-            previewText: "draft",
-            currentText: "",
-        })).toBe(false);
-        expect(canRemoveVoicePreview({
-            documentSize: 20,
-            anchor: 4,
-            previewText: "draft",
-            currentText: "sent",
-        })).toBe(false);
-    });
-});
-//# sourceMappingURL=TiptapComposer.spec.js.map