Add frontend regression test suite

.github/workflows/ci.yml

@@ -93,3 +93,9 @@ jobs:
 
       - name: Build frontend
         run: npm run build
+
+      - name: Install Chromium
+        run: npx playwright install --with-deps chromium
+
+      - name: Run browser tests
+        run: npm run test:e2e

.gitignore

@@ -251,3 +251,4 @@ workshop_AIE/
 
 # Local course-content working data (private Thinkific curriculum mapping + markdown) — never commit
 /full_stack_course/
+/output/playwright/

frontend/components/chat-message.test.tsx

@@ -0,0 +1,234 @@
+import { cleanup, fireEvent, render, screen, within } from "@testing-library/react";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { ChatMessage } from "@/components/chat-message";
+import type { TutorMessage, TutorMessagePart } from "@/lib/chat-ui";
+
+afterEach(cleanup);
+
+function assistantMessage(
+  parts: TutorMessagePart[],
+  id = "assistant-message",
+): TutorMessage {
+  return { id, role: "assistant", parts } as unknown as TutorMessage;
+}
+
+describe("ChatMessage activity rendering", () => {
+  it("preserves reasoning, tool, reasoning order and counts merged thoughts", () => {
+    render(
+      <ChatMessage
+        showAssistantActions={false}
+        message={assistantMessage([
+          { type: "reasoning", text: "First thought" },
+          { type: "reasoning", text: "Continuation of the first thought" },
+          {
+            type: "tool-retrieve_tutor_context",
+            toolCallId: "retrieve-1",
+            state: "output-available",
+            input: { query: "agent memory" },
+            output: {
+              matches: [
+                { docId: "doc-a", url: "https://example.com/a" },
+                { docId: "doc-b", url: "https://example.com/b" },
+                // Repeated evidence must not inflate the source count.
+                { docId: "doc-a", url: "https://example.com/a#section" },
+              ],
+            },
+          },
+          { type: "reasoning", text: "Second thought after retrieval" },
+          { type: "text", text: "Final answer" },
+        ])}
+      />,
+    );
+
+    const activityToggle = screen.getByRole("button", {
+      name: "Activity · 1 tool · 2 thoughts · 2 sources",
+    });
+    expect(activityToggle.getAttribute("aria-expanded")).toBe("false");
+
+    fireEvent.click(activityToggle);
+
+    const items = within(screen.getByRole("list")).getAllByRole("listitem");
+    expect(items).toHaveLength(3);
+    expect(items[0]?.textContent).toContain("First thought");
+    expect(items[0]?.textContent).toContain("Continuation of the first thought");
+    expect(items[1]?.textContent).toContain("Hybrid search");
+    expect(items[1]?.textContent).toContain("agent memory");
+    expect(items[2]?.textContent).toContain("Second thought after retrieval");
+    expect(screen.getByText("Final answer")).toBeTruthy();
+  });
+
+  it("shows Running only while a tool call is genuinely unfinished", () => {
+    const { rerender } = render(
+      <ChatMessage
+        isStreaming
+        showAssistantActions={false}
+        message={assistantMessage([
+          { type: "reasoning", text: "I should search first" },
+          {
+            type: "tool-retrieve_tutor_context",
+            toolCallId: "retrieve-1",
+            state: "input-available",
+            input: { query: "transformer attention" },
+          },
+        ])}
+      />,
+    );
+
+    expect(
+      screen.getByRole("button", {
+        name: /Running Hybrid search transformer attention/,
+      }),
+    ).toBeTruthy();
+
+    rerender(
+      <ChatMessage
+        isStreaming
+        showAssistantActions={false}
+        message={assistantMessage([
+          { type: "reasoning", text: "I should search first" },
+          {
+            type: "tool-retrieve_tutor_context",
+            toolCallId: "retrieve-1",
+            state: "output-available",
+            input: { query: "transformer attention" },
+            output: {
+              matches: [
+                { docId: "attention", url: "https://example.com/attention" },
+              ],
+            },
+          },
+          { type: "reasoning", text: "The result answers the question" },
+        ])}
+      />,
+    );
+
+    expect(
+      screen.getByRole("button", {
+        name: "Activity · 1 tool · 2 thoughts · 1 source",
+      }),
+    ).toBeTruthy();
+    expect(screen.queryByText("Running")).toBeNull();
+    expect(screen.getByText("The result answers the question")).toBeTruthy();
+  });
+
+  it("uses the web icon for provider-native search tools", () => {
+    render(
+      <ChatMessage
+        showAssistantActions={false}
+        message={assistantMessage([
+          {
+            type: "tool-google_search",
+            toolCallId: "search-1",
+            state: "output-available",
+            input: { query: "latest LangChain release" },
+            output: { text: "Search results" },
+          },
+        ])}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Activity · 1 tool" }));
+    const toolItem = screen.getByRole("listitem");
+    expect(toolItem.querySelector(".lucide-globe")).not.toBeNull();
+    expect(toolItem.querySelector(".lucide-database")).toBeNull();
+  });
+
+  it("bounds expanded tool output by both line and character limits", () => {
+    const lineLimitedOutput = "one\ntwo\nthree\nfour\nfive\nsix";
+    const characterLimitedOutput = `${"x".repeat(1005)}TAIL`;
+
+    render(
+      <ChatMessage
+        showAssistantActions={false}
+        message={assistantMessage([
+          {
+            type: "tool-run_kb_command",
+            toolCallId: "kb-1",
+            state: "output-available",
+            input: { text: "head raw/docs/file.md" },
+            output: { text: lineLimitedOutput },
+          },
+          {
+            type: "tool-custom_reader",
+            toolCallId: "custom-1",
+            state: "output-available",
+            input: { text: "read the long result" },
+            output: { text: characterLimitedOutput },
+          },
+        ])}
+      />,
+    );
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Activity · 2 tools" }),
+    );
+    fireEvent.click(
+      screen.getByRole("button", { name: /KB shell.*6 lines/ }),
+    );
+
+    const lineTruncation = screen.getByText(/truncated \(4 chars more\)/);
+    const linePreview = lineTruncation.closest("pre");
+    expect(linePreview?.firstChild?.textContent).toBe(
+      "one\ntwo\nthree\nfour\nfive",
+    );
+    expect(linePreview?.textContent).not.toContain("six");
+
+    fireEvent.click(
+      screen.getByRole("button", { name: /Custom Reader.*1\.0k chars/ }),
+    );
+
+    const characterTruncation = screen.getByText(/truncated \(9 chars more\)/);
+    const characterPreview = characterTruncation.closest("pre");
+    expect(characterPreview?.firstChild?.textContent).toHaveLength(1000);
+    expect(characterPreview?.textContent).not.toContain("TAIL");
+  });
+});
+
+describe("ChatMessage citations", () => {
+  it("reuses an inline citation number on its source card and keeps unsafe links inert", () => {
+    const { container } = render(
+      <ChatMessage
+        showAssistantActions={false}
+        message={assistantMessage([
+          {
+            type: "text",
+            text: [
+              "[Trusted](https://example.com/docs#section)",
+              "[Again](https://example.com/docs/)",
+              "[Unsafe](javascript:alert(1))",
+              "[Missing KB file](raw/docs/missing.md)",
+            ].join(" "),
+          },
+          {
+            type: "data-source",
+            data: {
+              docId: "docs-1",
+              title: "Docs title",
+              url: "https://example.com/docs",
+              sourceKey: "example",
+              sourceLabel: "Example Docs",
+              score: 0.9,
+              group: "docs",
+            },
+          },
+        ])}
+      />,
+    );
+
+    const inlineChips = Array.from(
+      container.querySelectorAll<HTMLAnchorElement>("a.citation-chip"),
+    );
+    expect(inlineChips).toHaveLength(2);
+    expect(inlineChips.map((chip) => chip.textContent)).toEqual(["1", "1"]);
+
+    const sourceCard = screen.getByTitle("Docs · Example Docs");
+    expect(sourceCard.tagName).toBe("A");
+    expect(sourceCard.getAttribute("href")).toBe("https://example.com/docs");
+    expect(sourceCard.textContent).toContain("1");
+    expect(sourceCard.textContent).toContain("Docs title");
+
+    expect(screen.getByText("Unsafe").closest("a")).toBeNull();
+    expect(screen.getByText("Missing KB file").closest("a")).toBeNull();
+  });
+});

frontend/components/chat-message.tsx

@@ -574,12 +574,12 @@ function ToolKindIcon({ type, className }: { type: string; className?: string })
   if (name.includes("kb_command") || name.includes("shell") || name.includes("command")) {
     return <Terminal className={className} />;
   }
-  if (name.includes("retrieve") || name.includes("search")) {
-    return <Database className={className} />;
-  }
   if (name.includes("web") || name.includes("url") || name.includes("google")) {
     return <Globe className={className} />;
   }
+  if (name.includes("retrieve") || name.includes("search")) {
+    return <Database className={className} />;
+  }
   return <Wrench className={className} />;
 }
 

frontend/components/chat-shell.test.tsx

@@ -0,0 +1,556 @@
+import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const fetchToolsMock = vi.hoisted(() => vi.fn());
+
+const chatHarness = vi.hoisted(() => ({
+  messages: [] as Array<{
+    id: string;
+    role: "assistant" | "user";
+    parts: Array<{ type: "text"; text: string }>;
+  }>,
+  status: "ready" as "error" | "ready" | "streaming" | "submitted",
+  error: null as Error | null,
+  onData: undefined as ((part: unknown) => void) | undefined,
+  sendMessage: vi.fn(),
+  setMessages: vi.fn(),
+  regenerate: vi.fn(),
+  stop: vi.fn(),
+  clearError: vi.fn(),
+  transportOptions: undefined as unknown,
+}));
+
+vi.mock("@/lib/api", async (importOriginal) => {
+  const original = await importOriginal<typeof import("@/lib/api")>();
+  return {
+    ...original,
+    fetchTools: fetchToolsMock,
+    getApiBaseUrl: () => "http://localhost:8000",
+  };
+});
+
+vi.mock("@ai-sdk/react", async () => {
+  const { useReducer } = await import("react");
+  return {
+    useChat: (options: { onData?: (part: unknown) => void }) => {
+      const [, forceRender] = useReducer((version: number) => version + 1, 0);
+      chatHarness.onData = options.onData;
+      return {
+        messages: chatHarness.messages,
+        sendMessage: chatHarness.sendMessage,
+        setMessages: (next: typeof chatHarness.messages) => {
+          chatHarness.setMessages(next);
+          forceRender();
+        },
+        regenerate: chatHarness.regenerate,
+        stop: chatHarness.stop,
+        status: chatHarness.status,
+        error: chatHarness.error,
+        clearError: chatHarness.clearError,
+      };
+    },
+  };
+});
+
+vi.mock("ai", () => ({
+  DefaultChatTransport: class DefaultChatTransport {
+    constructor(options: unknown) {
+      chatHarness.transportOptions = options;
+    }
+  },
+}));
+
+vi.mock("@/components/source-sidebar", () => ({
+  SourceSidebar: ({
+    onNewChat,
+    onToggleSource,
+    onToggleTool,
+    sourceError,
+  }: {
+    onNewChat: () => void;
+    onToggleSource: (key: string) => void;
+    onToggleTool: (key: string) => void;
+    sourceError: string | null;
+  }) => (
+    <aside>
+      <button type="button" onClick={onNewChat}>
+        New chat
+      </button>
+      <button type="button" onClick={() => onToggleSource("course-default")}>
+        Toggle default course
+      </button>
+      <button type="button" onClick={() => onToggleSource("docs-optional")}>
+        Toggle optional docs
+      </button>
+      <button type="button" onClick={() => onToggleTool("web_search")}>
+        Toggle web search
+      </button>
+      {sourceError ? <p role="alert">{sourceError}</p> : null}
+    </aside>
+  ),
+}));
+
+vi.mock("@/components/chat-message", () => ({
+  ChatMessage: ({
+    message,
+    isEditing,
+    editDraft,
+    onAssistantRedo,
+    onEditChange,
+    onEditSave,
+    onUserEdit,
+  }: {
+    message: {
+      id: string;
+      role: "assistant" | "user";
+      parts: Array<{ type: string; text?: string }>;
+    };
+    isEditing: boolean;
+    editDraft: string;
+    onAssistantRedo: (messageId: string) => void;
+    onEditChange: (value: string) => void;
+    onEditSave: (messageId: string) => void;
+    onUserEdit: (messageId: string) => void;
+  }) => {
+    const text = message.parts
+      .filter((part) => part.type === "text")
+      .map((part) => part.text ?? "")
+      .join("");
+
+    return (
+      <div data-testid={`message-${message.id}`}>
+        {isEditing ? (
+          <>
+            <textarea
+              aria-label={`Edit ${message.id}`}
+              value={editDraft}
+              onChange={(event) => onEditChange(event.target.value)}
+            />
+            <button type="button" onClick={() => onEditSave(message.id)}>
+              Save {message.id}
+            </button>
+          </>
+        ) : (
+          <span>{text}</span>
+        )}
+        {message.role === "user" && !isEditing ? (
+          <button type="button" onClick={() => onUserEdit(message.id)}>
+            Edit {message.id}
+          </button>
+        ) : null}
+        {message.role === "assistant" ? (
+          <button type="button" onClick={() => onAssistantRedo(message.id)}>
+            Redo {message.id}
+          </button>
+        ) : null}
+      </div>
+    );
+  },
+}));
+
+import { ChatShell } from "@/components/chat-shell";
+
+const DEFAULT_MODEL = "deepseek:deepseek-v4-flash";
+const CLAUDE_MODEL = "anthropic:claude-haiku-4-5";
+
+const toolsResponse = {
+  model: DEFAULT_MODEL,
+  availableModels: [
+    { id: DEFAULT_MODEL, label: "DeepSeek V4 Flash" },
+    { id: CLAUDE_MODEL, label: "Claude Haiku 4.5" },
+  ],
+  tools: [
+    {
+      kind: "configurable" as const,
+      key: "retrieval" as const,
+      label: "Knowledge base",
+      active: true,
+      sources: [
+        {
+          key: "course-default",
+          label: "Default course",
+          shortLabel: "Course",
+          group: "courses" as const,
+          selectedByDefault: true,
+        },
+        {
+          key: "docs-optional",
+          label: "Optional docs",
+          shortLabel: "Docs",
+          group: "docs" as const,
+          selectedByDefault: false,
+        },
+      ],
+    },
+    {
+      kind: "toggle" as const,
+      key: "web_search",
+      label: "Web search",
+      active: true,
+    },
+    {
+      kind: "toggle" as const,
+      key: "url_context",
+      label: "URL context",
+      active: false,
+    },
+  ],
+};
+
+function message(
+  id: string,
+  role: "assistant" | "user",
+  text: string,
+) {
+  return { id, role, parts: [{ type: "text" as const, text }] };
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, reject, resolve };
+}
+
+function sentBody(callIndex = 0) {
+  return chatHarness.sendMessage.mock.calls[callIndex]?.[1]?.body;
+}
+
+beforeEach(() => {
+  chatHarness.messages = [];
+  chatHarness.status = "ready";
+  chatHarness.error = null;
+  chatHarness.onData = undefined;
+  chatHarness.transportOptions = undefined;
+  chatHarness.sendMessage.mockReset();
+  chatHarness.regenerate.mockReset();
+  chatHarness.stop.mockReset();
+  chatHarness.clearError.mockReset();
+  chatHarness.setMessages.mockReset();
+  chatHarness.setMessages.mockImplementation(
+    (next: typeof chatHarness.messages) => {
+      chatHarness.messages = next;
+    },
+  );
+  fetchToolsMock.mockReset();
+  fetchToolsMock.mockResolvedValue(toolsResponse);
+});
+
+describe("ChatShell request lifecycle", () => {
+  it("keeps Send disabled until the initial tool and model defaults are ready", async () => {
+    const pendingTools = deferred<typeof toolsResponse>();
+    fetchToolsMock.mockReturnValueOnce(pendingTools.promise);
+    const user = userEvent.setup();
+
+    render(<ChatShell />);
+    await user.type(screen.getByRole("textbox"), "What is RAG?");
+
+    expect(
+      (screen.getByRole("button", { name: "Send message" }) as HTMLButtonElement)
+        .disabled,
+    ).toBe(true);
+    await user.keyboard("{Enter}");
+    const suggestion = screen
+      .getByRole("heading", { name: "Ask your AI tutor" })
+      .parentElement?.querySelector("button");
+    expect(suggestion).not.toBeNull();
+    await user.click(suggestion!);
+    expect(chatHarness.sendMessage).not.toHaveBeenCalled();
+
+    await act(async () => pendingTools.resolve(toolsResponse));
+
+    await waitFor(() =>
+      expect(
+        (screen.getByRole("button", {
+          name: "Send message",
+        }) as HTMLButtonElement).disabled,
+      ).toBe(false),
+    );
+  });
+
+  it("submits the loaded model, default sources, and active tools", async () => {
+    const user = userEvent.setup();
+    render(<ChatShell />);
+    await screen.findByRole("button", { name: "DeepSeek V4 Flash" });
+
+    await user.type(screen.getByRole("textbox"), "  Explain agents  ");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(chatHarness.sendMessage).toHaveBeenCalledWith(
+      { text: "Explain agents" },
+      {
+        body: {
+          sourceKeys: ["course-default"],
+          enabledTools: ["web_search"],
+          includeReasoning: true,
+          threadId: "",
+          model: DEFAULT_MODEL,
+        },
+      },
+    );
+  });
+
+  it("sends the user's current source and tool selections, including no sources", async () => {
+    const user = userEvent.setup();
+    render(<ChatShell />);
+    await screen.findByRole("button", { name: "DeepSeek V4 Flash" });
+
+    await user.click(screen.getByRole("button", { name: "Toggle optional docs" }));
+    await user.click(screen.getByRole("button", { name: "Toggle web search" }));
+    await user.type(screen.getByRole("textbox"), "Selected sources");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(sentBody()).toMatchObject({
+      sourceKeys: ["course-default", "docs-optional"],
+      enabledTools: [],
+    });
+
+    await user.click(screen.getByRole("button", { name: "Toggle default course" }));
+    await user.click(screen.getByRole("button", { name: "Toggle optional docs" }));
+    await user.type(screen.getByRole("textbox"), "No knowledge base");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(sentBody(1)).toMatchObject({ sourceKeys: [], enabledTools: [] });
+  });
+
+  it("adopts data-thread immediately and sends it with the next turn", async () => {
+    const user = userEvent.setup();
+    render(<ChatShell />);
+    await screen.findByRole("button", { name: "DeepSeek V4 Flash" });
+
+    await user.type(screen.getByRole("textbox"), "First question");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    act(() => {
+      chatHarness.onData?.({
+        type: "data-thread",
+        data: { threadId: "thread-from-server" },
+      });
+    });
+    await user.type(screen.getByRole("textbox"), "Follow up");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(sentBody(1)).toMatchObject({ threadId: "thread-from-server" });
+
+    act(() => {
+      chatHarness.onData?.({
+        type: "data-thread",
+        data: { threadId: "replacement-thread" },
+      });
+    });
+    await user.type(screen.getByRole("textbox"), "One more turn");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(sentBody(2)).toMatchObject({ threadId: "replacement-thread" });
+  });
+
+  it("locks model switching for an existing conversation and unlocks on New chat", async () => {
+    chatHarness.messages = [message("u1", "user", "First question")];
+    const user = userEvent.setup();
+    render(<ChatShell />);
+
+    const modelPicker = await screen.findByRole("button", {
+      name: "DeepSeek V4 Flash",
+    });
+    expect((modelPicker as HTMLButtonElement).disabled).toBe(true);
+
+    await user.click(screen.getByRole("button", { name: "New chat" }));
+
+    expect(chatHarness.setMessages).toHaveBeenCalledWith([]);
+    await waitFor(() =>
+      expect((modelPicker as HTMLButtonElement).disabled).toBe(false),
+    );
+  });
+
+  it("clears a failed model-specific tools request after a successful retry", async () => {
+    fetchToolsMock
+      .mockResolvedValueOnce(toolsResponse)
+      .mockRejectedValueOnce(new Error("Unable to load Claude tools"))
+      .mockResolvedValueOnce(toolsResponse);
+    const user = userEvent.setup();
+    render(<ChatShell />);
+
+    await user.click(
+      await screen.findByRole("button", { name: "DeepSeek V4 Flash" }),
+    );
+    await user.click(screen.getByRole("option", { name: "Claude Haiku 4.5" }));
+    expect(await screen.findByRole("alert")).toHaveTextContent(
+      "Unable to load Claude tools",
+    );
+
+    await user.click(screen.getByRole("button", { name: "Claude Haiku 4.5" }));
+    await user.click(screen.getByRole("option", { name: "DeepSeek V4 Flash" }));
+
+    await waitFor(() => expect(fetchToolsMock).toHaveBeenCalledTimes(3));
+    await waitFor(() => expect(screen.queryByRole("alert")).toBeNull());
+  });
+
+  it("pauses submissions while model-specific tools are reloading", async () => {
+    const pendingClaudeTools = deferred<typeof toolsResponse>();
+    fetchToolsMock
+      .mockResolvedValueOnce(toolsResponse)
+      .mockReturnValueOnce(pendingClaudeTools.promise);
+    const user = userEvent.setup();
+    render(<ChatShell />);
+
+    await user.click(
+      await screen.findByRole("button", { name: "DeepSeek V4 Flash" }),
+    );
+    await user.click(screen.getByRole("option", { name: "Claude Haiku 4.5" }));
+    await waitFor(() => expect(fetchToolsMock).toHaveBeenCalledTimes(2));
+
+    await user.type(screen.getByRole("textbox"), "Compare the providers");
+    await waitFor(() =>
+      expect(
+        (screen.getByRole("button", {
+          name: "Send message",
+        }) as HTMLButtonElement).disabled,
+      ).toBe(true),
+    );
+    await user.keyboard("{Enter}");
+    expect(chatHarness.sendMessage).not.toHaveBeenCalled();
+
+    await act(async () => pendingClaudeTools.resolve(toolsResponse));
+    await waitFor(() =>
+      expect(
+        (screen.getByRole("button", {
+          name: "Send message",
+        }) as HTMLButtonElement).disabled,
+      ).toBe(false),
+    );
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(sentBody()).toMatchObject({ model: CLAUDE_MODEL });
+  });
+
+  it("keeps the registry ready when the active model is selected again", async () => {
+    const user = userEvent.setup();
+    render(<ChatShell />);
+
+    await user.click(
+      await screen.findByRole("button", { name: "DeepSeek V4 Flash" }),
+    );
+    await user.click(screen.getByRole("option", { name: "DeepSeek V4 Flash" }));
+    expect(fetchToolsMock).toHaveBeenCalledOnce();
+
+    await user.type(screen.getByRole("textbox"), "Still ready");
+    const sendButton = screen.getByRole("button", { name: "Send message" });
+    expect((sendButton as HTMLButtonElement).disabled).toBe(false);
+    await user.click(sendButton);
+    expect(chatHarness.sendMessage).toHaveBeenCalledOnce();
+  });
+
+  it("clears a previous stream error and allows a retry", async () => {
+    chatHarness.status = "error";
+    chatHarness.error = new Error("The previous request failed");
+    const user = userEvent.setup();
+    render(<ChatShell />);
+    await screen.findByRole("button", { name: "DeepSeek V4 Flash" });
+
+    expect(screen.getByText("The previous request failed")).toBeVisible();
+    await user.type(screen.getByRole("textbox"), "Try again");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(chatHarness.clearError).toHaveBeenCalled();
+    expect(chatHarness.sendMessage).toHaveBeenCalledWith(
+      { text: "Try again" },
+      expect.objectContaining({ body: expect.any(Object) }),
+    );
+  });
+
+  it.each(["submitted", "streaming"] as const)(
+    "offers Stop and aborts while the request is %s",
+    async (status) => {
+      chatHarness.status = status;
+      const user = userEvent.setup();
+      render(<ChatShell />);
+
+      await user.click(screen.getByRole("button", { name: "Stop generating" }));
+
+      expect(chatHarness.stop).toHaveBeenCalledTimes(1);
+      expect(chatHarness.sendMessage).not.toHaveBeenCalled();
+    },
+  );
+
+  it("passes the selected message boundary to edit and regenerate", async () => {
+    chatHarness.messages = [
+      message("u1", "user", "Original question"),
+      message("a1", "assistant", "First answer"),
+      message("u2", "user", "Later question"),
+      message("a2", "assistant", "Later answer"),
+    ];
+    const user = userEvent.setup();
+    render(<ChatShell />);
+    await screen.findByRole("button", { name: "DeepSeek V4 Flash" });
+
+    await user.click(screen.getByRole("button", { name: "Redo a1" }));
+    expect(chatHarness.regenerate).toHaveBeenCalledWith({
+      messageId: "a1",
+      body: expect.objectContaining({
+        model: DEFAULT_MODEL,
+        threadId: "",
+      }),
+    });
+
+    await user.click(screen.getByRole("button", { name: "Edit u1" }));
+    const editor = screen.getByRole("textbox", { name: "Edit u1" });
+    fireEvent.change(editor, { target: { value: "Rewritten question" } });
+    await user.click(screen.getByRole("button", { name: "Save u1" }));
+
+    expect(chatHarness.sendMessage).toHaveBeenCalledWith(
+      { text: "Rewritten question", messageId: "u1" },
+      {
+        body: expect.objectContaining({
+          model: DEFAULT_MODEL,
+          threadId: "",
+        }),
+      },
+    );
+  });
+
+  it("clears an adopted thread when starting a new chat", async () => {
+    const user = userEvent.setup();
+    render(<ChatShell />);
+    await screen.findByRole("button", { name: "DeepSeek V4 Flash" });
+
+    await user.type(screen.getByRole("textbox"), "First question");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    act(() => {
+      chatHarness.onData?.({
+        type: "data-thread",
+        data: { threadId: "old-thread" },
+      });
+    });
+    await user.click(screen.getByRole("button", { name: "New chat" }));
+    await user.type(screen.getByRole("textbox"), "Fresh question");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(sentBody(1)).toMatchObject({ threadId: "" });
+  });
+
+  it("ignores a late thread event from a stream abandoned by New chat", async () => {
+    chatHarness.status = "streaming";
+    const user = userEvent.setup();
+    render(<ChatShell />);
+    await waitFor(() => expect(fetchToolsMock).toHaveBeenCalledOnce());
+
+    await user.click(screen.getByRole("button", { name: "New chat" }));
+    expect(chatHarness.stop).toHaveBeenCalledOnce();
+
+    act(() => {
+      chatHarness.onData?.({
+        type: "data-thread",
+        data: { threadId: "late-abandoned-thread" },
+      });
+    });
+
+    chatHarness.status = "ready";
+    await user.type(screen.getByRole("textbox"), "Fresh after abort");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+
+    expect(sentBody()).toMatchObject({ threadId: "" });
+  });
+});

frontend/components/chat-shell.tsx

@@ -75,6 +75,7 @@ export function ChatShell() {
   const [selectedSourceKeys, setSelectedSourceKeys] = useState<string[]>([]);
   const [enabledToolKeys, setEnabledToolKeys] = useState<string[]>([]);
   const [sourceError, setSourceError] = useState<string | null>(null);
+  const [toolRegistryReady, setToolRegistryReady] = useState(false);
   const [input, setInput] = useState("");
   const [threadId, setThreadId] = useState("");
   const [copiedMessageId, setCopiedMessageId] = useState<string | null>(null);
@@ -84,6 +85,7 @@ export function ChatShell() {
   const composerInputRef = useRef<HTMLTextAreaElement>(null);
   const pendingScrollRef = useRef(false);
   const spacerRef = useRef<HTMLDivElement>(null);
+  const acceptThreadDataRef = useRef(false);
 
   const {
     messages,
@@ -97,7 +99,7 @@ export function ChatShell() {
   } = useChat({
     transport,
     onData: (part) => {
-      if (part.type === "data-thread") {
+      if (part.type === "data-thread" && acceptThreadDataRef.current) {
         const nextThreadId = (part as ThreadDataPart).data.threadId;
         if (nextThreadId) {
           // Urgent update on purpose: deferring it (startTransition) lets a
@@ -141,6 +143,7 @@ export function ChatShell() {
             .map((tool) => tool.key),
         );
         setSourceError(null);
+        setToolRegistryReady(true);
       } catch (loadError) {
         if (controller.signal.aborted) {
           return;
@@ -150,6 +153,7 @@ export function ChatShell() {
             ? loadError.message
             : "Unable to load tool registry.",
         );
+        setToolRegistryReady(false);
       }
     }
 
@@ -179,6 +183,8 @@ export function ChatShell() {
             .filter((tool) => tool.kind === "toggle" && tool.active)
             .map((tool) => tool.key),
         );
+        setSourceError(null);
+        setToolRegistryReady(true);
       } catch (loadError) {
         if (controller.signal.aborted) {
           return;
@@ -188,6 +194,7 @@ export function ChatShell() {
             ? loadError.message
             : "Unable to load tool registry.",
         );
+        setToolRegistryReady(false);
       }
     }
 
@@ -199,7 +206,8 @@ export function ChatShell() {
   // After a stream error the SDK parks status on "error" until clearError()
   // or the next request; handleSubmit clears it, so the error state must
   // stay sendable or the Send button locks out mouse users for good.
-  const canSend = status === "ready" || status === "error";
+  const canSend =
+    toolRegistryReady && (status === "ready" || status === "error");
   const typedMessages = messages as TutorMessage[];
   const latestMessage = typedMessages[typedMessages.length - 1];
   const streamingAssistantId =
@@ -282,11 +290,12 @@ export function ChatShell() {
 
   async function handleSubmit(override?: string) {
     const trimmed = (override ?? input).trim();
-    if (!trimmed || isStreaming) {
+    if (!trimmed || !canSend) {
       return;
     }
 
     clearError();
+    acceptThreadDataRef.current = true;
     setCopiedMessageId(null);
     setEditingMessageId(null);
     setEditingText("");
@@ -307,7 +316,11 @@ export function ChatShell() {
   }
 
   async function handleRedo(messageId?: string) {
+    if (!canSend) {
+      return;
+    }
     clearError();
+    acceptThreadDataRef.current = true;
     setCopiedMessageId(null);
     await regenerate({
       messageId,
@@ -362,11 +375,12 @@ export function ChatShell() {
 
   async function handleEditSave(messageId: string) {
     const trimmed = editingText.trim();
-    if (!trimmed || isStreaming) {
+    if (!trimmed || !canSend) {
       return;
     }
 
     clearError();
+    acceptThreadDataRef.current = true;
     setCopiedMessageId(null);
     setEditingMessageId(null);
     setEditingText("");
@@ -386,6 +400,7 @@ export function ChatShell() {
   }
 
   function handleNewChat() {
+    acceptThreadDataRef.current = false;
     if (isStreaming) {
       stop();
     }
@@ -500,7 +515,13 @@ export function ChatShell() {
                   <ModelPicker
                     availableModels={availableModels}
                     locked={typedMessages.length > 0}
-                    onSelect={setSelectedModel}
+                    onSelect={(modelId) => {
+                      if (modelId === selectedModel) {
+                        return;
+                      }
+                      setToolRegistryReady(false);
+                      setSelectedModel(modelId);
+                    }}
                     selectedModel={selectedModel}
                   />
                   <ComposerActionButton

frontend/components/markdown-block.test.tsx

@@ -0,0 +1,78 @@
+import { cleanup, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { MarkdownBlock } from "@/components/markdown-block";
+
+afterEach(cleanup);
+
+describe("MarkdownBlock links", () => {
+  it("renders short numbered links as chips but retains long claim text", () => {
+    const url = "https://example.com/reference";
+    const longClaim =
+      "This linked sentence is a substantive claim that should stay readable in the answer";
+
+    render(
+      <MarkdownBlock citationNumbers={new Map([[url, 1]])}>
+        {`[Short](${url}) and [${longClaim}](${url})`}
+      </MarkdownBlock>,
+    );
+
+    const chips = screen.getAllByRole("link", { name: "1" });
+    expect(chips).toHaveLength(2);
+    expect(chips.every((chip) => chip.getAttribute("href") === url)).toBe(true);
+    expect(screen.queryByText("Short")).toBeNull();
+    expect(screen.getByText(longClaim)).toBeTruthy();
+  });
+
+  it("allows external HTTP and email links while leaving unsafe and relative links inert", () => {
+    render(
+      <MarkdownBlock>
+        {
+          "[Website](https://safe.example/path) [Email](mailto:tutor@example.com) [Unsafe](javascript:alert(1)) [Local](raw/docs/private.md)"
+        }
+      </MarkdownBlock>,
+    );
+
+    const website = screen.getByRole("link", { name: "Website" });
+    expect(website.getAttribute("href")).toBe("https://safe.example/path");
+    expect(website.getAttribute("target")).toBe("_blank");
+    expect(website.getAttribute("rel")).toBe("noreferrer");
+
+    const email = screen.getByRole("link", { name: "Email" });
+    expect(email.getAttribute("href")).toBe("mailto:tutor@example.com");
+    expect(email.getAttribute("target")).toBe("_blank");
+    expect(email.getAttribute("rel")).toBe("noreferrer");
+
+    expect(screen.getByText("Unsafe").closest("a")).toBeNull();
+    expect(screen.getByText("Local").closest("a")).toBeNull();
+  });
+
+  it("resolves KB references before rendering and gives equivalent references the same number", () => {
+    const resolvedUrl = "https://docs.example.com/guide";
+    const citationNumbers = new Map([[resolvedUrl, 7]]);
+    const citationResolutions = new Map([
+      ["raw/docs/guide.md", resolvedUrl],
+      ["kb://doc/guide-id", resolvedUrl],
+    ]);
+
+    render(
+      <MarkdownBlock
+        citationNumbers={citationNumbers}
+        citationResolutions={citationResolutions}
+      >
+        {"[Raw path](raw/docs/guide.md) [Document ID](kb://doc/guide-id)"}
+      </MarkdownBlock>,
+    );
+
+    const chips = screen.getAllByRole("link", { name: "7" });
+    expect(chips).toHaveLength(2);
+    expect(chips.map((chip) => chip.getAttribute("href"))).toEqual([
+      resolvedUrl,
+      resolvedUrl,
+    ]);
+    expect(chips.map((chip) => chip.getAttribute("title"))).toEqual([
+      "Raw path",
+      "Document ID",
+    ]);
+  });
+});

frontend/components/source-sidebar.test.tsx

@@ -0,0 +1,119 @@
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { SourceSidebar } from "@/components/source-sidebar";
+import type { TutorSource, TutorTool } from "@/lib/api";
+
+afterEach(cleanup);
+
+const sources: TutorSource[] = [
+  {
+    key: "course-a",
+    label: "Course A",
+    shortLabel: "Course A",
+    description: "Learn practical agent engineering.",
+    infoUrl: "https://academy.example.com/course-a",
+    group: "courses",
+    selectedByDefault: true,
+  },
+  {
+    key: "docs-a",
+    label: "Documentation A",
+    shortLabel: "Docs A",
+    description: "Reference documentation for the library.",
+    infoUrl: "https://docs.example.com/",
+    group: "docs",
+    selectedByDefault: false,
+    version: "v1.2",
+    indexedAt: "2026-07-01",
+  },
+];
+
+const tools: TutorTool[] = [
+  {
+    kind: "configurable",
+    key: "retrieval",
+    label: "Knowledge base",
+    active: true,
+    sources,
+  },
+  {
+    kind: "toggle",
+    key: "web_search",
+    label: "Web search",
+    active: false,
+  },
+];
+
+function renderSidebar() {
+  const handlers = {
+    onNewChat: vi.fn(),
+    onToggleSource: vi.fn(),
+    onToggleTool: vi.fn(),
+  };
+  render(
+    <SourceSidebar
+      {...handlers}
+      selectedSourceKeys={["course-a"]}
+      enabledToolKeys={["web_search"]}
+      sourceError={null}
+      tools={tools}
+    />,
+  );
+  return handlers;
+}
+
+describe("SourceSidebar", () => {
+  it("reports active tools and routes new-chat, source, and tool actions", () => {
+    const handlers = renderSidebar();
+
+    expect(screen.getByText("2/2")).toBeTruthy();
+    expect(
+      screen.getByRole("button", { name: "Course A" }).getAttribute(
+        "aria-pressed",
+      ),
+    ).toBe("true");
+    expect(
+      screen.getByRole("button", { name: "Docs A" }).getAttribute(
+        "aria-pressed",
+      ),
+    ).toBe("false");
+    expect(
+      screen.getByRole("button", { name: "Web search" }).getAttribute(
+        "aria-pressed",
+      ),
+    ).toBe("true");
+
+    fireEvent.click(screen.getByRole("button", { name: "New chat" }));
+    fireEvent.click(screen.getByRole("button", { name: "Docs A" }));
+    fireEvent.click(screen.getByRole("button", { name: "Web search" }));
+
+    expect(handlers.onNewChat).toHaveBeenCalledOnce();
+    expect(handlers.onToggleSource).toHaveBeenCalledWith("docs-a");
+    expect(handlers.onToggleTool).toHaveBeenCalledWith("web_search");
+  });
+
+  it("shows registry metadata in a portaled source popover and closes it with Escape", () => {
+    renderSidebar();
+
+    const infoButton = screen.getByRole("button", {
+      name: "About Documentation A",
+    });
+    expect(infoButton.getAttribute("aria-expanded")).toBe("false");
+
+    fireEvent.click(infoButton);
+
+    const dialog = screen.getByRole("dialog");
+    expect(dialog.textContent).toContain(
+      "Reference documentation for the library.",
+    );
+    expect(dialog.textContent).toContain("v1.2 · indexed Jul 2026");
+    const docsLink = screen.getByRole("link", { name: /View docs/ });
+    expect(docsLink.getAttribute("href")).toBe("https://docs.example.com/");
+    expect(docsLink.getAttribute("target")).toBe("_blank");
+
+    fireEvent.keyDown(document, { key: "Escape" });
+    expect(screen.queryByRole("dialog")).toBeNull();
+    expect(infoButton.getAttribute("aria-expanded")).toBe("false");
+  });
+});

frontend/components/source-sidebar.tsx

@@ -480,7 +480,11 @@ function formatIndexedMonth(isoDate: string | null | undefined): string | null {
   if (!isoDate) return null;
   const date = new Date(isoDate);
   if (Number.isNaN(date.getTime())) return null;
-  return date.toLocaleString("en-US", { month: "short", year: "numeric" });
+  return date.toLocaleString("en-US", {
+    month: "short",
+    year: "numeric",
+    timeZone: "UTC",
+  });
 }
 
 function getPopoverInfo(source: TutorSource): PopoverInfo | undefined {

frontend/e2e/chat-flow.spec.ts

@@ -0,0 +1,202 @@
+import { expect, test, type Page } from "@playwright/test";
+
+const MODEL = "deepseek:deepseek-v4-flash";
+const largeToolOutput = "retrieved context ".repeat(20_000);
+
+const toolsResponse = {
+  model: MODEL,
+  availableModels: [{ id: MODEL, label: "DeepSeek V4 Flash" }],
+  tools: [
+    {
+      kind: "configurable",
+      key: "retrieval",
+      label: "Knowledge base",
+      active: true,
+      sources: [
+        {
+          key: "example-docs",
+          label: "Example documentation",
+          shortLabel: "Example docs",
+          description: "Documentation used by the browser test.",
+          infoUrl: "https://example.test/docs",
+          group: "docs",
+          selectedByDefault: true,
+          version: "v1.0",
+          indexedAt: "2026-07-01",
+        },
+      ],
+    },
+  ],
+};
+
+function sse(parts: Array<Record<string, unknown>>) {
+  return `${parts.map((part) => `data: ${JSON.stringify(part)}\n\n`).join("")}data: [DONE]\n\n`;
+}
+
+async function mockTools(page: Page) {
+  await page.route("**/api/tools**", (route) =>
+    route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify(toolsResponse),
+    }),
+  );
+}
+
+test("streams activity and sends a compact follow-up on the same thread", async ({
+  page,
+}) => {
+  const requests: Array<Record<string, unknown>> = [];
+  await mockTools(page);
+  await page.route("**/api/chat", async (route) => {
+    requests.push(route.request().postDataJSON() as Record<string, unknown>);
+    const firstTurn = requests.length === 1;
+    const parts = firstTurn
+      ? [
+          {
+            type: "data-thread",
+            data: { threadId: "thread-browser" },
+            transient: true,
+          },
+          { type: "start", messageId: "assistant-1" },
+          { type: "start-step" },
+          { type: "reasoning-start", id: "thought-1" },
+          { type: "reasoning-delta", id: "thought-1", delta: "First thought" },
+          { type: "reasoning-end", id: "thought-1" },
+          {
+            type: "tool-input-available",
+            toolCallId: "call-1",
+            toolName: "retrieve_tutor_context",
+            input: { query: "LoRA" },
+          },
+          {
+            type: "tool-output-available",
+            toolCallId: "call-1",
+            output: {
+              text: largeToolOutput,
+              matches: [
+                {
+                  docId: "lora-doc",
+                  title: "LoRA guide",
+                  url: "https://example.test/lora",
+                  sourceKey: "example-docs",
+                  sourceLabel: "Example docs",
+                  score: 0.9,
+                  group: "docs",
+                },
+              ],
+            },
+          },
+          { type: "reasoning-start", id: "thought-2" },
+          { type: "reasoning-delta", id: "thought-2", delta: "Second thought" },
+          { type: "reasoning-end", id: "thought-2" },
+          {
+            type: "source-url",
+            sourceId: "lora-doc",
+            url: "https://example.test/lora",
+          },
+          {
+            type: "data-source",
+            data: {
+              docId: "lora-doc",
+              title: "LoRA guide",
+              url: "https://example.test/lora",
+              sourceKey: "example-docs",
+              sourceLabel: "Example docs",
+              score: 0.9,
+              group: "docs",
+            },
+          },
+          { type: "text-start", id: "answer-1" },
+          {
+            type: "text-delta",
+            id: "answer-1",
+            delta: "LoRA is parameter-efficient [1](https://example.test/lora).",
+          },
+          { type: "text-end", id: "answer-1" },
+          { type: "finish-step" },
+          { type: "finish" },
+        ]
+      : [
+          { type: "start", messageId: "assistant-2" },
+          { type: "start-step" },
+          { type: "text-start", id: "answer-2" },
+          { type: "text-delta", id: "answer-2", delta: "Follow-up answer" },
+          { type: "text-end", id: "answer-2" },
+          { type: "finish-step" },
+          { type: "finish" },
+        ];
+    await route.fulfill({
+      status: 200,
+      headers: {
+        "content-type": "text/event-stream",
+        "x-vercel-ai-ui-message-stream": "v1",
+      },
+      body: sse(parts),
+    });
+  });
+
+  await page.goto("/");
+  await expect(page.getByRole("button", { name: "DeepSeek V4 Flash" })).toBeVisible();
+  const composer = page.getByRole("textbox");
+  await composer.fill("What is LoRA?");
+  await page.getByRole("button", { name: "Send message" }).click();
+
+  await expect(page.getByText("LoRA is parameter-efficient")).toBeVisible();
+  const activity = page.getByRole("button", {
+    name: "Activity · 1 tool · 2 thoughts · 1 source",
+  });
+  await expect(activity).toBeVisible();
+  await activity.click();
+  await expect(page.getByText("First thought")).toBeVisible();
+  await expect(page.getByText("Second thought")).toBeVisible();
+
+  await composer.fill("Can you expand?");
+  await page.getByRole("button", { name: "Send message" }).click();
+  await expect(page.getByText("Follow-up answer")).toBeVisible();
+  await expect.poll(() => requests.length).toBe(2);
+
+  const followUp = requests[1];
+  expect(followUp.threadId).toBe("thread-browser");
+  expect(JSON.stringify(followUp)).not.toContain(largeToolOutput.slice(0, 500));
+  expect(followUp.messages).toEqual([
+    expect.objectContaining({
+      role: "user",
+      parts: [{ type: "text", text: "What is LoRA?" }],
+    }),
+    expect.objectContaining({
+      role: "assistant",
+      parts: [
+        {
+          type: "text",
+          text: "LoRA is parameter-efficient [1](https://example.test/lora).",
+        },
+      ],
+    }),
+    expect.objectContaining({
+      role: "user",
+      parts: [{ type: "text", text: "Can you expand?" }],
+    }),
+  ]);
+});
+
+test("keeps controls and source metadata inside a narrow viewport", async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 812 });
+  await mockTools(page);
+  await page.goto("/");
+
+  await expect(page.getByRole("button", { name: "Send message" })).toBeVisible();
+  expect(
+    await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth),
+  ).toBe(true);
+
+  await page
+    .getByRole("button", { name: "About Example documentation" })
+    .click();
+  const dialog = page.getByRole("dialog");
+  await expect(dialog).toContainText("v1.0 · indexed Jul 2026");
+  const box = await dialog.boundingBox();
+  expect(box).not.toBeNull();
+  expect(box!.x).toBeGreaterThanOrEqual(0);
+  expect(box!.x + box!.width).toBeLessThanOrEqual(375);
+});

frontend/lib/api.test.mts

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fetchTools, getApiBaseUrl, type ToolsResponse } from "./api.ts";
+
+const ENV_NAME = "NEXT_PUBLIC_AI_TUTOR_API_BASE_URL";
+
+function restoreEnvironment(previous: string | undefined) {
+  if (previous === undefined) {
+    delete process.env[ENV_NAME];
+  } else {
+    process.env[ENV_NAME] = previous;
+  }
+}
+
+test("getApiBaseUrl prefers configured URLs and removes trailing slashes", () => {
+  const previous = process.env[ENV_NAME];
+  try {
+    process.env[ENV_NAME] = "https://api.example.test/tutor///";
+    assert.equal(getApiBaseUrl(), "https://api.example.test/tutor");
+  } finally {
+    restoreEnvironment(previous);
+  }
+});
+
+test("getApiBaseUrl uses the browser origin, then the server fallback", () => {
+  const previousEnv = process.env[ENV_NAME];
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  try {
+    delete process.env[ENV_NAME];
+    Object.defineProperty(globalThis, "window", {
+      configurable: true,
+      value: { location: { origin: "https://browser.example.test" } },
+    });
+    assert.equal(getApiBaseUrl(), "https://browser.example.test");
+
+    delete (globalThis as { window?: unknown }).window;
+    assert.equal(getApiBaseUrl(), "http://127.0.0.1:8000");
+  } finally {
+    restoreEnvironment(previousEnv);
+    if (previousWindow) {
+      Object.defineProperty(globalThis, "window", previousWindow);
+    } else {
+      delete (globalThis as { window?: unknown }).window;
+    }
+  }
+});
+
+test("fetchTools sends the model query and AbortSignal and returns parsed JSON", async () => {
+  const previousEnv = process.env[ENV_NAME];
+  const previousFetch = globalThis.fetch;
+  const calls: Array<{ url: string; init: RequestInit | undefined }> = [];
+  const expected: ToolsResponse = {
+    model: "deepseek:deepseek-v4-flash",
+    availableModels: [
+      { id: "deepseek:deepseek-v4-flash", label: "DeepSeek V4 Flash" },
+    ],
+    tools: [],
+  };
+  const controller = new AbortController();
+
+  try {
+    process.env[ENV_NAME] = "https://api.example.test/base/";
+    globalThis.fetch = (async (input, init) => {
+      calls.push({ url: String(input), init });
+      return new Response(JSON.stringify(expected), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as typeof fetch;
+
+    const actual = await fetchTools(
+      controller.signal,
+      "deepseek:deepseek-v4-flash",
+    );
+
+    assert.deepEqual(actual, expected);
+    assert.equal(calls.length, 1);
+    assert.equal(
+      calls[0]?.url,
+      "https://api.example.test/base/api/tools?model=deepseek%3Adeepseek-v4-flash",
+    );
+    assert.equal(calls[0]?.init?.method, "GET");
+    assert.equal(calls[0]?.init?.signal, controller.signal);
+  } finally {
+    restoreEnvironment(previousEnv);
+    globalThis.fetch = previousFetch;
+  }
+});
+
+test("fetchTools omits an empty model and reports non-success status codes", async () => {
+  const previousEnv = process.env[ENV_NAME];
+  const previousFetch = globalThis.fetch;
+  let requestedUrl = "";
+
+  try {
+    process.env[ENV_NAME] = "https://api.example.test";
+    globalThis.fetch = (async (input) => {
+      requestedUrl = String(input);
+      return new Response("unavailable", { status: 503 });
+    }) as typeof fetch;
+
+    await assert.rejects(fetchTools(undefined, ""), {
+      name: "Error",
+      message: "Unable to load tools (503)",
+    });
+    assert.equal(requestedUrl, "https://api.example.test/api/tools");
+  } finally {
+    restoreEnvironment(previousEnv);
+    globalThis.fetch = previousFetch;
+  }
+});

frontend/lib/chat-http-transport.test.mts

@@ -0,0 +1,130 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { Chat } from "@ai-sdk/react";
+import { DefaultChatTransport, type UIMessage, type UIMessageChunk } from "ai";
+
+import { prepareTutorChatRequest } from "./chat-transport.ts";
+
+function sseResponse(chunks: UIMessageChunk[]) {
+  const body = [
+    ...chunks.map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`),
+    "data: [DONE]\n\n",
+  ].join("");
+  return new Response(body, {
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream",
+      "x-vercel-ai-ui-message-stream": "v1",
+    },
+  });
+}
+
+test("DefaultChatTransport sends compact history and preserves checkpoint identity", async () => {
+  const largeToolOutput = "retrieved context ".repeat(20_000);
+  const originalAssistantText = "  Exact streamed answer  \n";
+  const initialMessages = [
+    {
+      id: "user-1",
+      role: "user",
+      parts: [{ type: "text", text: "Question" }],
+    },
+    {
+      id: "assistant-1",
+      role: "assistant",
+      parts: [
+        { type: "reasoning", text: "Private thought" },
+        {
+          type: "tool-retrieve_tutor_context",
+          toolCallId: "call-1",
+          state: "output-available",
+          input: { query: "Question" },
+          output: { text: largeToolOutput, matches: [] },
+        },
+        { type: "source-url", sourceId: "source-1", url: "https://example.test" },
+        { type: "text", text: originalAssistantText },
+      ],
+    },
+  ] as unknown as UIMessage[];
+
+  let requestBody: Record<string, unknown> | undefined;
+  const receivedData: unknown[] = [];
+  const transport = new DefaultChatTransport<UIMessage>({
+    api: "https://api.example.test/api/chat",
+    prepareSendMessagesRequest: prepareTutorChatRequest,
+    fetch: async (_input, init) => {
+      requestBody = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      return sseResponse([
+        {
+          type: "data-thread",
+          data: { threadId: "thread-1" },
+          transient: true,
+        },
+        { type: "start", messageId: "assistant-2" },
+        { type: "start-step" },
+        { type: "text-start", id: "answer-2" },
+        { type: "text-delta", id: "answer-2", delta: "Follow-up answer" },
+        { type: "text-end", id: "answer-2" },
+        { type: "finish-step" },
+        { type: "finish" },
+      ]);
+    },
+  });
+  const chat = new Chat<UIMessage>({
+    id: "chat-1",
+    messages: initialMessages,
+    transport,
+    onData: (part) => receivedData.push(part),
+  });
+
+  await chat.sendMessage(
+    { text: "Follow up" },
+    {
+      body: {
+        threadId: "thread-1",
+        model: "deepseek:deepseek-v4-flash",
+      },
+    },
+  );
+
+  assert.ok(requestBody);
+  assert.equal(requestBody.threadId, "thread-1");
+  assert.equal(requestBody.model, "deepseek:deepseek-v4-flash");
+  assert.deepEqual(requestBody.messages, [
+    {
+      id: "user-1",
+      role: "user",
+      parts: [{ type: "text", text: "Question" }],
+    },
+    {
+      id: "assistant-1",
+      role: "assistant",
+      parts: [{ type: "text", text: originalAssistantText }],
+    },
+    {
+      id: chat.messages[2]?.id,
+      role: "user",
+      parts: [{ type: "text", text: "Follow up" }],
+    },
+  ]);
+  assert.ok(JSON.stringify(requestBody).length < 2_000);
+  assert.deepEqual(receivedData, [
+    {
+      type: "data-thread",
+      data: { threadId: "thread-1" },
+      transient: true,
+    },
+  ]);
+
+  const retainedTool = chat.messages[1]?.parts.find((part) =>
+    part.type.startsWith("tool-"),
+  );
+  assert.equal(
+    (retainedTool as { output: { text: string } }).output.text,
+    largeToolOutput,
+  );
+  assert.equal(
+    (chat.messages[1]?.parts.at(-1) as { text: string }).text,
+    originalAssistantText,
+  );
+});

frontend/lib/chat-sdk-lifecycle.test.mts

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { Chat } from "@ai-sdk/react";
+import type { ChatTransport, UIMessage, UIMessageChunk } from "ai";
+
+type SendOptions = Parameters<ChatTransport<UIMessage>["sendMessages"]>[0];
+
+function assistantStream(messageId: string) {
+  const chunks: UIMessageChunk[] = [
+    { type: "start", messageId },
+    { type: "start-step" },
+    { type: "text-start", id: `${messageId}-text` },
+    { type: "text-delta", id: `${messageId}-text`, delta: "New answer" },
+    { type: "text-end", id: `${messageId}-text` },
+    { type: "finish-step" },
+    { type: "finish" },
+  ];
+  return new ReadableStream<UIMessageChunk>({
+    start(controller) {
+      for (const chunk of chunks) controller.enqueue(chunk);
+      controller.close();
+    },
+  });
+}
+
+class CapturingTransport implements ChatTransport<UIMessage> {
+  calls: Array<Omit<SendOptions, "messages"> & { messages: UIMessage[] }> = [];
+
+  async sendMessages(options: SendOptions) {
+    this.calls.push({
+      ...options,
+      messages: structuredClone(options.messages),
+    });
+    return assistantStream(`response-${this.calls.length}`);
+  }
+
+  async reconnectToStream() {
+    return null;
+  }
+}
+
+function transcript(): UIMessage[] {
+  return [
+    { id: "u1", role: "user", parts: [{ type: "text", text: "Question 1" }] },
+    { id: "a1", role: "assistant", parts: [{ type: "text", text: "Answer 1" }] },
+    { id: "u2", role: "user", parts: [{ type: "text", text: "Question 2" }] },
+    { id: "a2", role: "assistant", parts: [{ type: "text", text: "Answer 2" }] },
+    { id: "u3", role: "user", parts: [{ type: "text", text: "Question 3" }] },
+    { id: "a3", role: "assistant", parts: [{ type: "text", text: "Answer 3" }] },
+  ];
+}
+
+function messageSummary(messages: UIMessage[]) {
+  return messages.map((message) => ({
+    id: message.id,
+    role: message.role,
+    text: message.parts
+      .filter((part) => part.type === "text")
+      .map((part) => part.text)
+      .join(""),
+  }));
+}
+
+test("editing a user turn replaces it and drops its answer and later turns", async () => {
+  const transport = new CapturingTransport();
+  const chat = new Chat<UIMessage>({
+    id: "chat-edit",
+    messages: transcript(),
+    transport,
+  });
+
+  await chat.sendMessage({ text: "Question 2 edited", messageId: "u2" });
+
+  assert.equal(transport.calls.length, 1);
+  assert.equal(transport.calls[0].trigger, "submit-message");
+  assert.equal(transport.calls[0].messageId, "u2");
+  assert.deepEqual(messageSummary(transport.calls[0].messages), [
+    { id: "u1", role: "user", text: "Question 1" },
+    { id: "a1", role: "assistant", text: "Answer 1" },
+    { id: "u2", role: "user", text: "Question 2 edited" },
+  ]);
+});
+
+test("regenerating an assistant turn replays its user prompt and drops later turns", async () => {
+  const transport = new CapturingTransport();
+  const chat = new Chat<UIMessage>({
+    id: "chat-regenerate",
+    messages: transcript(),
+    transport,
+  });
+
+  await chat.regenerate({ messageId: "a2" });
+
+  assert.equal(transport.calls.length, 1);
+  assert.equal(transport.calls[0].trigger, "regenerate-message");
+  assert.equal(transport.calls[0].messageId, "a2");
+  assert.deepEqual(messageSummary(transport.calls[0].messages), [
+    { id: "u1", role: "user", text: "Question 1" },
+    { id: "a1", role: "assistant", text: "Answer 1" },
+    { id: "u2", role: "user", text: "Question 2" },
+  ]);
+});
+
+test("regenerating an earlier answer removes every subsequent turn", async () => {
+  const transport = new CapturingTransport();
+  const chat = new Chat<UIMessage>({
+    id: "chat-regenerate-earlier",
+    messages: transcript(),
+    transport,
+  });
+
+  await chat.regenerate({ messageId: "a1" });
+
+  assert.deepEqual(messageSummary(transport.calls[0].messages), [
+    { id: "u1", role: "user", text: "Question 1" },
+  ]);
+});

frontend/lib/chat-stream.test.mts

@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  readUIMessageStream,
+  type UIMessage,
+  type UIMessageChunk,
+} from "ai";
+
+import { compactChatMessages } from "./chat-transport.ts";
+
+function streamChunks(chunks: UIMessageChunk[]) {
+  return new ReadableStream<UIMessageChunk>({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(chunk);
+      }
+      controller.close();
+    },
+  });
+}
+
+async function foldChunks(chunks: UIMessageChunk[]) {
+  let latest: UIMessage | undefined;
+  for await (const message of readUIMessageStream({
+    stream: streamChunks(chunks),
+  })) {
+    latest = message;
+  }
+  assert.ok(latest, "the stream should produce an assistant message");
+  return latest;
+}
+
+test("folds reasoning, tools, sources, and text in provider order", async () => {
+  const message = await foldChunks([
+    { type: "start", messageId: "assistant-1" },
+    { type: "start-step" },
+    { type: "reasoning-start", id: "thought-1" },
+    { type: "reasoning-delta", id: "thought-1", delta: "First thought" },
+    { type: "reasoning-end", id: "thought-1" },
+    {
+      type: "tool-input-start",
+      toolCallId: "call-1",
+      toolName: "retrieve_tutor_context",
+    },
+    {
+      type: "tool-input-available",
+      toolCallId: "call-1",
+      toolName: "retrieve_tutor_context",
+      input: { query: "LoRA" },
+    },
+    {
+      type: "tool-output-available",
+      toolCallId: "call-1",
+      output: { text: "retrieved context", matches: [] },
+    },
+    { type: "reasoning-start", id: "thought-2" },
+    { type: "reasoning-delta", id: "thought-2", delta: "Second thought" },
+    { type: "reasoning-end", id: "thought-2" },
+    {
+      type: "source-url",
+      sourceId: "source-1",
+      url: "https://example.com/lora",
+      title: "LoRA guide",
+    },
+    {
+      type: "data-source",
+      data: {
+        title: "LoRA guide",
+        url: "https://example.com/lora",
+        source: "docs",
+      },
+    },
+    { type: "text-start", id: "answer-1" },
+    {
+      type: "text-delta",
+      id: "answer-1",
+      delta: "  LoRA is parameter-efficient.\n",
+    },
+    { type: "text-end", id: "answer-1" },
+    { type: "finish-step" },
+    { type: "finish" },
+  ]);
+
+  assert.equal(message.id, "assistant-1");
+  assert.equal(message.role, "assistant");
+  assert.deepEqual(
+    message.parts.map((part) => part.type),
+    [
+      "step-start",
+      "reasoning",
+      "tool-retrieve_tutor_context",
+      "reasoning",
+      "source-url",
+      "data-source",
+      "text",
+    ],
+  );
+  assert.equal(
+    (message.parts[1] as { text: string }).text,
+    "First thought",
+  );
+  assert.equal(
+    (message.parts[3] as { text: string }).text,
+    "Second thought",
+  );
+  assert.equal(
+    (message.parts[6] as { text: string }).text,
+    "  LoRA is parameter-efficient.\n",
+  );
+});
+
+test("folded tool state stays in the UI while follow-up history is text-only", async () => {
+  const largeOutput = "retrieved context ".repeat(20_000);
+  const assistant = await foldChunks([
+    { type: "start", messageId: "assistant-1" },
+    { type: "start-step" },
+    {
+      type: "tool-input-available",
+      toolCallId: "call-1",
+      toolName: "retrieve_tutor_context",
+      input: { query: "LoRA" },
+    },
+    {
+      type: "tool-output-available",
+      toolCallId: "call-1",
+      output: { text: largeOutput, matches: [] },
+    },
+    { type: "text-start", id: "answer-1" },
+    { type: "text-delta", id: "answer-1", delta: "Exact answer  \n" },
+    { type: "text-end", id: "answer-1" },
+    { type: "finish-step" },
+    { type: "finish" },
+  ]);
+
+  const toolPart = assistant.parts.find((part) => part.type.startsWith("tool-"));
+  assert.ok(toolPart);
+  assert.equal(
+    (toolPart as { output: { text: string } }).output.text,
+    largeOutput,
+  );
+
+  const compacted = compactChatMessages([
+    { id: "user-1", role: "user", parts: [{ type: "text", text: "Question" }] },
+    assistant,
+    {
+      id: "user-2",
+      role: "user",
+      parts: [{ type: "text", text: "Follow up" }],
+    },
+  ]);
+
+  assert.deepEqual(compacted[1].parts, [
+    { type: "text", text: "Exact answer  \n" },
+  ]);
+  assert.ok(JSON.stringify(compacted).length < 1_000);
+  assert.equal(
+    (toolPart as { output: { text: string } }).output.text,
+    largeOutput,
+    "request compaction must not mutate folded UI state",
+  );
+});

frontend/lib/chat-ui.test.mts

@@ -0,0 +1,284 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { SourcePartData } from "./api.ts";
+import {
+  buildActivityItems,
+  buildCitationNumbers,
+  buildCitationResolutions,
+  citationNumberFor,
+  getMessageCitations,
+  getMessageTextContent,
+  getOrderedMessageBlocks,
+  hasRenderableContent,
+  resolveCitationHref,
+  type TutorMessage,
+  type TutorMessagePart,
+} from "./chat-ui.ts";
+
+function assistantMessage(
+  parts: TutorMessagePart[],
+  id = "assistant-1",
+): TutorMessage {
+  return { id, role: "assistant", parts } as unknown as TutorMessage;
+}
+
+function source(overrides: Partial<SourcePartData> = {}): SourcePartData {
+  return {
+    docId: "doc-1",
+    title: "A useful source",
+    url: "https://docs.example.test/guide",
+    sourceKey: "docs",
+    sourceLabel: "Example docs",
+    score: 0.9,
+    group: "docs",
+    ...overrides,
+  };
+}
+
+test("citation numbers follow rendered-link order and ignore non-rendered links", () => {
+  const message = assistantMessage([
+    {
+      type: "text",
+      text: [
+        "[Nested [label]](https://docs.example.test/Spring_(framework)#intro)",
+        "`[inline code](https://ignored.example.test/inline)`",
+        "![image](https://ignored.example.test/image)",
+        "```md\n[fenced](https://ignored.example.test/fenced)\n```",
+        "[Duplicate](https://docs.example.test/Spring_(framework)/)",
+      ].join("\n"),
+    },
+    {
+      type: "text",
+      text: [
+        "[Encoded](https://docs.example.test/caf%C3%A9)",
+        "[Unicode duplicate](https://docs.example.test/café#heading)",
+        "[Angle form](<https://other.example.test/a(b)>)",
+        "[With title](https://third.example.test/path \"Source title\")",
+        "[Malformed](https://ignored.example.test/wrong]",
+        "[Relative](raw/docs/example.md)",
+      ].join("\n"),
+    },
+  ]);
+
+  const numbers = buildCitationNumbers(message);
+
+  assert.deepEqual([...numbers.entries()], [
+    ["https://docs.example.test/Spring_(framework)", 1],
+    ["https://docs.example.test/caf%C3%A9", 2],
+    ["https://other.example.test/a(b)", 3],
+    ["https://third.example.test/path", 4],
+  ]);
+  assert.equal(citationNumberFor(numbers, "https://docs.example.test/café/"), 2);
+  assert.equal(citationNumberFor(numbers, "https://ignored.example.test/inline"), undefined);
+});
+
+test("KB references resolve to one navigable citation number", () => {
+  const canonicalUrl = "https://academy.example.test/lessons/lora";
+  const kbSource = source({
+    docId: "lora-doc",
+    path: "raw/docs/peft/lora.md",
+    url: canonicalUrl,
+  });
+  const message = assistantMessage([
+    {
+      type: "text",
+      text: [
+        "[By id](kb://doc/lora-doc)",
+        "[By relative path](./raw/docs/peft/lora.md)",
+        "[By full path](data/kb/raw/docs/peft/lora.md)",
+        "[Direct URL](https://academy.example.test/lessons/lora#examples)",
+        "[Missing KB file](raw/docs/peft/missing.md)",
+      ].join(" "),
+    },
+    { type: "data-source", data: kbSource },
+  ]);
+
+  const resolutions = buildCitationResolutions(message);
+  assert.deepEqual([...resolutions.entries()], [
+    ["kb://doc/lora-doc", canonicalUrl],
+    ["raw/docs/peft/lora.md", canonicalUrl],
+  ]);
+  assert.equal(
+    resolveCitationHref("data/kb/raw/docs/peft/lora.md", resolutions),
+    canonicalUrl,
+  );
+  assert.equal(resolveCitationHref("raw/docs/peft/missing.md", resolutions), undefined);
+
+  const numbers = buildCitationNumbers(message, resolutions);
+  assert.deepEqual([...numbers.entries()], [[canonicalUrl, 1]]);
+  assert.equal(citationNumberFor(numbers, `${canonicalUrl}/#details`), 1);
+});
+
+test("server-provided sources preserve order and deduplicate normalized URLs", () => {
+  const longTitle = "T".repeat(90);
+  const message = assistantMessage([
+    {
+      type: "data-source",
+      data: source({
+        title: longTitle,
+        url: "https://docs.example.test/guide/#intro",
+        group: "docs",
+      }),
+    },
+    {
+      type: "data-source",
+      data: source({
+        title: "Duplicate",
+        url: "https://docs.example.test/guide/",
+        group: "docs",
+      }),
+    },
+    {
+      type: "data-source",
+      data: source({
+        title: "   —   ",
+        url: "https://www.search.example.test/result",
+        sourceLabel: "Search result",
+        group: "web",
+      }),
+    },
+    {
+      type: "data-source",
+      data: source({
+        title: "Course lesson",
+        url: "https://academy.example.test/course/lesson",
+        sourceLabel: "Agent Engineering",
+        group: "courses",
+      }),
+    },
+    { type: "data-source", data: source({ url: "   " }) },
+  ]);
+
+  assert.deepEqual(getMessageCitations(message), [
+    {
+      label: longTitle.slice(0, 80),
+      url: "https://docs.example.test/guide/#intro",
+      kind: "doc",
+      sublabel: "Example docs",
+    },
+    {
+      label: "search.example.test",
+      url: "https://www.search.example.test/result",
+      kind: "web",
+      sublabel: "search.example.test",
+    },
+    {
+      label: "Course lesson",
+      url: "https://academy.example.test/course/lesson",
+      kind: "course",
+      sublabel: "Agent Engineering",
+    },
+  ]);
+});
+
+test("ordered blocks retain provider order and ignored parts do not split blocks", () => {
+  const reasoningOne = { type: "reasoning", text: "First thought" };
+  const reasoningTwo = { type: "reasoning", text: "Second fragment" };
+  const tool = {
+    type: "tool-retrieve_tutor_context",
+    toolCallId: "call-1",
+    state: "output-available",
+  };
+  const reasoningThree = { type: "reasoning", text: "After the tool" };
+  const textOne = { type: "text", text: "Answer one" };
+  const textTwo = { type: "text", text: "Answer two" };
+  const finalTool = {
+    type: "tool-web_search",
+    toolCallId: "call-2",
+    state: "input-available",
+  };
+  const message = assistantMessage([
+    { type: "data-source", data: source() },
+    reasoningOne,
+    { type: "data-context_stats", data: { tokens: 10 } },
+    reasoningTwo,
+    tool,
+    reasoningThree,
+    textOne,
+    { type: "data-source", data: source() },
+    textTwo,
+    finalTool,
+  ]);
+
+  assert.deepEqual(getOrderedMessageBlocks(message), [
+    {
+      key: "assistant-1-activity-0",
+      kind: "activity",
+      parts: [reasoningOne, reasoningTwo, tool, reasoningThree],
+    },
+    {
+      key: "assistant-1-text-1",
+      kind: "text",
+      parts: [textOne, textTwo],
+    },
+    {
+      key: "assistant-1-activity-2",
+      kind: "activity",
+      parts: [finalTool],
+    },
+  ]);
+});
+
+test("activity items merge reasoning fragments but split them at tool calls", () => {
+  const tool = {
+    type: "tool-run_kb_command",
+    toolCallId: "call-1",
+    state: "output-available",
+  };
+  const parts: TutorMessagePart[] = [
+    { type: "reasoning", text: "  First fragment  " },
+    { type: "data-source", data: source() },
+    { type: "reasoning", text: "" },
+    { type: "reasoning", text: "Second fragment" },
+    tool,
+    { type: "data-context_stats", data: {} },
+    { type: "reasoning", text: "Final thought" },
+  ];
+
+  assert.deepEqual(buildActivityItems(parts), [
+    {
+      kind: "reasoning",
+      key: "r-0",
+      text: "First fragment\n\nSecond fragment",
+    },
+    { kind: "tool", key: "t-1-call-1", part: tool },
+    { kind: "reasoning", key: "r-2", text: "Final thought" },
+  ]);
+});
+
+test("renderability ignores empty stream placeholders but retains real activity", () => {
+  assert.equal(hasRenderableContent(assistantMessage([])), false);
+  assert.equal(
+    hasRenderableContent(assistantMessage([{ type: "data-source", data: source() }])),
+    false,
+  );
+  assert.equal(hasRenderableContent(assistantMessage([{ type: "text", text: "" }])), false);
+  assert.equal(
+    hasRenderableContent(assistantMessage([{ type: "reasoning", text: "" }])),
+    false,
+  );
+  assert.equal(
+    hasRenderableContent(assistantMessage([{ type: "reasoning", text: "Thinking" }])),
+    true,
+  );
+  assert.equal(
+    hasRenderableContent(
+      assistantMessage([{ type: "tool-web_search", state: "input-streaming" }]),
+    ),
+    true,
+  );
+});
+
+test("message text joins trimmed non-empty text parts without reshaping content inside them", () => {
+  const message = assistantMessage([
+    { type: "text", text: "  First paragraph\n  " },
+    { type: "reasoning", text: "Not user-facing" },
+    { type: "text", text: "   " },
+    { type: "text", text: "Second paragraph\nwith another line" },
+  ]);
+
+  assert.equal(
+    getMessageTextContent(message),
+    "First paragraph\n\nSecond paragraph\nwith another line",
+  );
+});

frontend/lib/chat-ui.ts

@@ -109,7 +109,14 @@ export function hasRenderableContent(message: TutorMessage): boolean {
       continue;
     }
     const type = String(part.type);
-    if (type === "text" || type === "reasoning" || type.startsWith("tool-")) {
+    if (type === "text" || type === "reasoning") {
+      const text = "text" in part ? part.text : "";
+      if (typeof text === "string" && text.trim()) {
+        return true;
+      }
+      continue;
+    }
+    if (type.startsWith("tool-")) {
       return true;
     }
   }

frontend/package-lock.json

@@ -22,16 +22,29 @@
       },
       "devDependencies": {
         "@eslint/eslintrc": "^3.3.1",
+        "@playwright/test": "^1.61.1",
         "@tailwindcss/postcss": "^4.1.17",
+        "@testing-library/jest-dom": "^6.9.1",
+        "@testing-library/react": "^16.3.2",
+        "@testing-library/user-event": "^14.6.1",
         "@types/node": "^24.10.1",
         "@types/react": "^19.2.2",
         "@types/react-dom": "^19.2.2",
         "eslint": "^9.39.4",
         "eslint-config-next": "^16.2.3",
+        "jsdom": "^29.1.1",
         "tailwindcss": "^4.2.2",
-        "typescript": "^6.0.3"
+        "typescript": "^6.0.3",
+        "vitest": "^4.1.10"
       }
     },
+    "node_modules/@adobe/css-tools": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.5.0.tgz",
+      "integrity": "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@ai-sdk/gateway": {
       "version": "3.0.143",
       "resolved": "https://registry.npmjs.org/@ai-sdk/gateway/-/gateway-3.0.143.tgz",
@@ -109,6 +122,57 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "5.1.11",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz",
+      "integrity": "sha512-KVw6qIiCTUQhByfTd78h2yD1/00waTmm9uy/R7Ck/ctUyAPj+AEDLkQIdJW0T8+qGgj3j5bpNKK7Q3G+LedJWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@csstools/css-calc": "^3.2.0",
+        "@csstools/css-color-parser": "^4.1.0",
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-7.1.1.tgz",
+      "integrity": "sha512-67RZDnYRc8H/8MLDgQCDE//zoqVFwajkepHZgmXrbwybzXOEwOWGPYGmALYl9J2DOLfFPPs6kKCqmbzV895hTQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@asamuzakjp/nwsapi": "^2.3.9",
+        "bidi-js": "^1.0.3",
+        "css-tree": "^3.2.1",
+        "is-potential-custom-element-name": "^1.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/generational-cache": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/generational-cache/-/generational-cache-1.0.1.tgz",
+      "integrity": "sha512-wajfB8KqzMCN2KGNFdLkReeHncd0AslUSrvHVvvYWuU8ghncRJoA50kT3zP9MVL0+9g4/67H+cdvBskj9THPzg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/nwsapi": {
+      "version": "2.3.9",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
+      "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@babel/code-frame": {
       "version": "7.29.7",
       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
@@ -301,6 +365,16 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/template": {
       "version": "7.29.7",
       "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
@@ -349,6 +423,159 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@bramus/specificity": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
+      "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "css-tree": "^3.0.0"
+      },
+      "bin": {
+        "specificity": "bin/cli.js"
+      }
+    },
+    "node_modules/@csstools/color-helpers": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.1.0.tgz",
+      "integrity": "sha512-064IFJdjTfUqnjpCVpMOdbr8FLQBhinbZj6yRv2An2E41O/pLEXqfFRWqGq/SxlE5PEUYTlvWsG2r8MswAVvkg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.2.1.tgz",
+      "integrity": "sha512-DtdHlgXh5ZkA43cwBcAm+huzgJiwx3ZTWVjBs94kwz2xKqSimDA3lBgCjphYgwgVUMWatSM0pDd8TILB1yrVVg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.1.9.tgz",
+      "integrity": "sha512-paQcIaOO53Rk5+YrBaBjm/SgrV4INImjo2BT1DtQRYr+XeTRbeAYlS+jxXp9drqvKmtFnWRJKIalDLhZZDu42A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^6.1.0",
+        "@csstools/css-calc": "^3.2.1"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",
+      "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-syntax-patches-for-csstree": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.6.tgz",
+      "integrity": "sha512-TcJCWFbXLPpJYq6z7bfOyjWYJDiDg2/I4gyUC9pqPNqHFRIey0EB0q0L5cSnQDfWJg8Jd6VadakxdIez/3zkqQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "peerDependencies": {
+        "css-tree": "^3.2.1"
+      },
+      "peerDependenciesMeta": {
+        "css-tree": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz",
+      "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
     "node_modules/@emnapi/core": {
       "version": "1.10.0",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
@@ -526,6 +753,24 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@exodus/bytes": {
+      "version": "1.15.1",
+      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz",
+      "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@noble/hashes": "^1.8.0 || ^2.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@noble/hashes": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@humanfs/core": {
       "version": "0.19.2",
       "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
@@ -1388,72 +1633,36 @@
         "node": ">=8.0.0"
       }
     },
-    "node_modules/@rtsao/scc": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz",
-      "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@standard-schema/spec": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
-      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
-      "license": "MIT"
-    },
-    "node_modules/@swc/helpers": {
-      "version": "0.5.15",
-      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.15.tgz",
-      "integrity": "sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.8.0"
-      }
-    },
-    "node_modules/@tailwindcss/node": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.3.2.tgz",
-      "integrity": "sha512-yWP/sqEcBLaD8JuA6zNwxoYKr75qxTioYwlRwekj5Jr/I5GXnoJfjetH/psLUIv74cYTH2lBUEzBkinthoYcBg==",
+    "node_modules/@oxc-project/types": {
+      "version": "0.139.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.139.0.tgz",
+      "integrity": "sha512-r9gHphtCs+1M7J0pw6Sn/hh/Wpa/iQrOOkrNAlVLF/gHq+/CJmHIWKKUUhdWjcD6CIa8idarspCsASiXCXvFUw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@jridgewell/remapping": "^2.3.5",
-        "enhanced-resolve": "5.21.6",
-        "jiti": "^2.7.0",
-        "lightningcss": "1.32.0",
-        "magic-string": "^0.30.21",
-        "source-map-js": "^1.2.1",
-        "tailwindcss": "4.3.2"
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
       }
     },
-    "node_modules/@tailwindcss/oxide": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.3.2.tgz",
-      "integrity": "sha512-z8ZgnzX8gdNoWLBLqBPoh/sjnxkwvf9ZuWjnO0l0yIzbLa5/9S+eC5QxGZKRobVHIC3/1BoMWjHblqWjcgFgag==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 20"
+    "node_modules/@playwright/test": {
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.61.1.tgz",
+      "integrity": "sha512-8nKv6+0RJSL9FE4jYOEGXnPeM/Hg12qZpmqzZjRh3qM0Y7c3z1mrOTfFLids72RDQYVh9WpLEfR5WdpNX4fkig==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright": "1.61.1"
       },
-      "optionalDependencies": {
-        "@tailwindcss/oxide-android-arm64": "4.3.2",
-        "@tailwindcss/oxide-darwin-arm64": "4.3.2",
-        "@tailwindcss/oxide-darwin-x64": "4.3.2",
-        "@tailwindcss/oxide-freebsd-x64": "4.3.2",
-        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.2",
-        "@tailwindcss/oxide-linux-arm64-gnu": "4.3.2",
-        "@tailwindcss/oxide-linux-arm64-musl": "4.3.2",
-        "@tailwindcss/oxide-linux-x64-gnu": "4.3.2",
-        "@tailwindcss/oxide-linux-x64-musl": "4.3.2",
-        "@tailwindcss/oxide-wasm32-wasi": "4.3.2",
-        "@tailwindcss/oxide-win32-arm64-msvc": "4.3.2",
-        "@tailwindcss/oxide-win32-x64-msvc": "4.3.2"
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@tailwindcss/oxide-android-arm64": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.3.2.tgz",
-      "integrity": "sha512-WHxqIuHpvZ5VtdX6GTl1Ik/Vp2YuN42Et+0CdeaVd/frQ9jAvGmvR8vLT+jk3e8/Q3x8kECB9+R17pgpp2BulA==",
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.1.5.tgz",
+      "integrity": "sha512-lZg8fqIv2v7FF237bwMgzGZEJvGL79/s5knJ/i6FmsGF4XXlzccZ4jb+TrFIxtSSxFtIpdsgrPZeMk1I9AFcyQ==",
       "cpu": [
         "arm64"
       ],
@@ -1464,13 +1673,13 @@
         "android"
       ],
       "engines": {
-        "node": ">= 20"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@tailwindcss/oxide-darwin-arm64": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.3.2.tgz",
-      "integrity": "sha512-GZypeUY/IDJW3877KeM+O67vbXr3MBnbtEL4aYhNErv/JWZhye2vGSWWG9tB6iiqR2MqRNkY8IOUy4NdSZV26w==",
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.1.5.tgz",
+      "integrity": "sha512-51Bnx9pNiMRKSUNtBfySkNJ9vMU9Hh3I1ozDd6gyPPYzaXCfnptUcEZxXGYFn+ul2dtcMUiqGR1Yai2K10uoTw==",
       "cpu": [
         "arm64"
       ],
@@ -1481,13 +1690,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">= 20"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@tailwindcss/oxide-darwin-x64": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.3.2.tgz",
-      "integrity": "sha512-UIIzmefR6KO1sDU7MzRqAxC8iBpft/VhkGjTjnhoS6k7Z3rQ9wEgA1ODSiyH/tcSYssulNm4Ci3hOeK1jH7ccQ==",
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.1.5.tgz",
+      "integrity": "sha512-Tm+gbfC0aHu1tBA/JvKQh32S0K6YgCHkiAF4/W6xX0K0RmNuc94VeK419dJoE65R5aRxmo+noZQSWrAMF6yb6g==",
       "cpu": [
         "x64"
       ],
@@ -1498,13 +1707,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">= 20"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@tailwindcss/oxide-freebsd-x64": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.3.2.tgz",
-      "integrity": "sha512-GN+uAmcI6DNspnCDwtOAZrTz6oukJnp337qZvxqCGLd3BHBzJpO0ZbTLRvJNdztOeAmTzewewGIMPb0tk2R4WA==",
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.1.5.tgz",
+      "integrity": "sha512-JMzDKCCXq93YccG5gz3hvOs1oXRKAf0XYpfOS88e+wZrC8Iugj6j68867vrYZkvpDDpKn/KoKORThmchMpF6TA==",
       "cpu": [
         "x64"
       ],
@@ -1515,13 +1724,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">= 20"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.3.2.tgz",
-      "integrity": "sha512-4ABn7qSbdHRwTiDiuWNegCyb5+2FJ4vKIKc3DmKrvAFw7MU1Lm11dIkTPwUaFdTzc7IsOpDbqBrlh0x6y36U/w==",
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.1.5.tgz",
+      "integrity": "sha512-uML21j2K5TfPGutKxub+M+nLjZIrWjXQ5Grx4lCe/nimTj9B4L63zHpjXLl4y0L3mcm2htEQIb06oCG/szerNw==",
       "cpu": [
         "arm"
       ],
@@ -1532,13 +1741,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">= 20"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@tailwindcss/oxide-linux-arm64-gnu": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.3.2.tgz",
-      "integrity": "sha512-wDgEIGwoM8w8pufh9LVt1PahDgNdKXrLC2qfAnV3vAmococ9RWbxeAw4pxPttd/TsJfwjyLf90Dg1y9y8I6Emw==",
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.1.5.tgz",
+      "integrity": "sha512-navSiuTMogvnQoZoM/v+l3ZWo50/NTwSHSzheABx/RCnmUPaKwq9qSo4Br2OYRs21+Fz8uFqITZM3H4opOB0/Q==",
       "cpu": [
         "arm64"
       ],
@@ -1552,13 +1761,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">= 20"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@tailwindcss/oxide-linux-arm64-musl": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.3.2.tgz",
-      "integrity": "sha512-J5Nuk0uZQIiMTJj3LEx4sAA9tMFUoXQZFv1J6An+QGYe53HKRJuFDi0rpq/tuouCZeAbOBY3kQ6g8qeD4TUjtA==",
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.1.5.tgz",
+      "integrity": "sha512-lAryqH7IteztmCXQXk0etKj4wBQ7Gx5S6LjKhsgp9zb8I5bsuvU/2llH1hDQcjsFeqIsovMVN339/8pUDDBXxA==",
       "cpu": [
         "arm64"
       ],
@@ -1572,15 +1781,393 @@
         "linux"
       ],
       "engines": {
-        "node": ">= 20"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@tailwindcss/oxide-linux-x64-gnu": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.3.2.tgz",
-      "integrity": "sha512-kqCZpSKOBEJO4mz7OqWoofBZeXTAwaVGPj0ErAj7CojmhKpWVWVOnrt9dE8odoIraZq4oj3ausM37kXi+Tow8w==",
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.1.5.tgz",
+      "integrity": "sha512-fsK/sNBnxzBlL4O1JNrZakVQxPspqpED5dLtNsZS9oOKmtSpdNIzxH2kkol5HYTWJN47sE20ztMJPxfZ89qGOg==",
       "cpu": [
-        "x64"
+        "ppc64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.1.5.tgz",
+      "integrity": "sha512-gLYb4BIadlfTOYT5gO503n8zQjXflgzpD0FcyKh0Mzx3rqCZKnHoJWV9xe1KXUJ5lx2JfcSHr/mhzS0PC/McAA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.1.5.tgz",
+      "integrity": "sha512-FjcpEKUyJygHgs1o50VYNvkt5+7Le/VEdYt0AkRpkL33MnyQfwr8l5mXwMmfmTbyMPr5vJLC+8/Gd9gXnwU1QQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.1.5.tgz",
+      "integrity": "sha512-Me+PfPI2TMeOQk0gYWfLQZtTktrmzbr8cDboqX83XKc7UrgAi55gF+2dUkWdxd19n55Essp2yeca+O9N5rBxHg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.1.5.tgz",
+      "integrity": "sha512-yc5WrLzXks6zCQfn9Oxr8pORKyl/pF+QjHmW/Qx3qu0oyrrNC+y2JLTU1E2rcWYAmzlnqngWXHQjy51VzW70Vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.1.5.tgz",
+      "integrity": "sha512-VbQGPX2b4r48TAMIM2cjgluIM1HYutm4pcTEJsle7iEP7sB1dFqtPLBVbdLAZCxy1txCcPxf4QFf4v8uvltPqA==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "1.11.1",
+        "@emnapi/runtime": "1.11.1",
+        "@napi-rs/wasm-runtime": "^1.1.6"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi/node_modules/@emnapi/core": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.1.tgz",
+      "integrity": "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.2",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi/node_modules/@emnapi/runtime": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.1.tgz",
+      "integrity": "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi/node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.2.tgz",
+      "integrity": "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.1.5.tgz",
+      "integrity": "sha512-gHv82k63z4qpV5+Q1y/12KrK0ltWBukVDI8nZcbT7Tt/ZlOIVwppazneq0F93oDxTo3IgAMEDIoQh3E2n6mVsw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.1.5.tgz",
+      "integrity": "sha512-tTZuDBPw85tEN5PQi1pnEBzDy0Z49HtScLAbD5t6hyeU92A95pRWaSMw1GZZi/RwgSgUIl0xrSlXIT/9QzvYSA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rtsao/scc": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz",
+      "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "license": "MIT"
+    },
+    "node_modules/@swc/helpers": {
+      "version": "0.5.15",
+      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.15.tgz",
+      "integrity": "sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
+      }
+    },
+    "node_modules/@tailwindcss/node": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.3.2.tgz",
+      "integrity": "sha512-yWP/sqEcBLaD8JuA6zNwxoYKr75qxTioYwlRwekj5Jr/I5GXnoJfjetH/psLUIv74cYTH2lBUEzBkinthoYcBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.5",
+        "enhanced-resolve": "5.21.6",
+        "jiti": "^2.7.0",
+        "lightningcss": "1.32.0",
+        "magic-string": "^0.30.21",
+        "source-map-js": "^1.2.1",
+        "tailwindcss": "4.3.2"
+      }
+    },
+    "node_modules/@tailwindcss/oxide": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.3.2.tgz",
+      "integrity": "sha512-z8ZgnzX8gdNoWLBLqBPoh/sjnxkwvf9ZuWjnO0l0yIzbLa5/9S+eC5QxGZKRobVHIC3/1BoMWjHblqWjcgFgag==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      },
+      "optionalDependencies": {
+        "@tailwindcss/oxide-android-arm64": "4.3.2",
+        "@tailwindcss/oxide-darwin-arm64": "4.3.2",
+        "@tailwindcss/oxide-darwin-x64": "4.3.2",
+        "@tailwindcss/oxide-freebsd-x64": "4.3.2",
+        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.2",
+        "@tailwindcss/oxide-linux-arm64-gnu": "4.3.2",
+        "@tailwindcss/oxide-linux-arm64-musl": "4.3.2",
+        "@tailwindcss/oxide-linux-x64-gnu": "4.3.2",
+        "@tailwindcss/oxide-linux-x64-musl": "4.3.2",
+        "@tailwindcss/oxide-wasm32-wasi": "4.3.2",
+        "@tailwindcss/oxide-win32-arm64-msvc": "4.3.2",
+        "@tailwindcss/oxide-win32-x64-msvc": "4.3.2"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-android-arm64": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.3.2.tgz",
+      "integrity": "sha512-WHxqIuHpvZ5VtdX6GTl1Ik/Vp2YuN42Et+0CdeaVd/frQ9jAvGmvR8vLT+jk3e8/Q3x8kECB9+R17pgpp2BulA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-arm64": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.3.2.tgz",
+      "integrity": "sha512-GZypeUY/IDJW3877KeM+O67vbXr3MBnbtEL4aYhNErv/JWZhye2vGSWWG9tB6iiqR2MqRNkY8IOUy4NdSZV26w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-x64": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.3.2.tgz",
+      "integrity": "sha512-UIIzmefR6KO1sDU7MzRqAxC8iBpft/VhkGjTjnhoS6k7Z3rQ9wEgA1ODSiyH/tcSYssulNm4Ci3hOeK1jH7ccQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-freebsd-x64": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.3.2.tgz",
+      "integrity": "sha512-GN+uAmcI6DNspnCDwtOAZrTz6oukJnp337qZvxqCGLd3BHBzJpO0ZbTLRvJNdztOeAmTzewewGIMPb0tk2R4WA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.3.2.tgz",
+      "integrity": "sha512-4ABn7qSbdHRwTiDiuWNegCyb5+2FJ4vKIKc3DmKrvAFw7MU1Lm11dIkTPwUaFdTzc7IsOpDbqBrlh0x6y36U/w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-gnu": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.3.2.tgz",
+      "integrity": "sha512-wDgEIGwoM8w8pufh9LVt1PahDgNdKXrLC2qfAnV3vAmococ9RWbxeAw4pxPttd/TsJfwjyLf90Dg1y9y8I6Emw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-musl": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.3.2.tgz",
+      "integrity": "sha512-J5Nuk0uZQIiMTJj3LEx4sAA9tMFUoXQZFv1J6An+QGYe53HKRJuFDi0rpq/tuouCZeAbOBY3kQ6g8qeD4TUjtA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-gnu": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.3.2.tgz",
+      "integrity": "sha512-kqCZpSKOBEJO4mz7OqWoofBZeXTAwaVGPj0ErAj7CojmhKpWVWVOnrt9dE8odoIraZq4oj3ausM37kXi+Tow8w==",
+      "cpu": [
+        "x64"
       ],
       "dev": true,
       "libc": [
@@ -1693,6 +2280,107 @@
         "tailwindcss": "4.3.2"
       }
     },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/dom/node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
+    "node_modules/@testing-library/jest-dom": {
+      "version": "6.9.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-6.9.1.tgz",
+      "integrity": "sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@adobe/css-tools": "^4.4.0",
+        "aria-query": "^5.0.0",
+        "css.escape": "^1.5.1",
+        "dom-accessibility-api": "^0.6.3",
+        "picocolors": "^1.1.1",
+        "redent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14",
+        "npm": ">=6",
+        "yarn": ">=1"
+      }
+    },
+    "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz",
+      "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@testing-library/react": {
+      "version": "16.3.2",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.2.tgz",
+      "integrity": "sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.12.5"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": "^10.0.0",
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@testing-library/user-event": {
+      "version": "14.6.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz",
+      "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=7.21.4"
+      }
+    },
     "node_modules/@tybys/wasm-util": {
       "version": "0.10.3",
       "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.3.tgz",
@@ -1704,6 +2392,25 @@
         "tslib": "^2.4.0"
       }
     },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
     "node_modules/@types/debug": {
       "version": "4.1.13",
       "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
@@ -1713,6 +2420,13 @@
         "@types/ms": "*"
       }
     },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.9",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
@@ -2428,41 +3142,154 @@
         "win32"
       ]
     },
-    "node_modules/@unrs/resolver-binding-win32-ia32-msvc": {
-      "version": "1.12.2",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-ia32-msvc/-/resolver-binding-win32-ia32-msvc-1.12.2.tgz",
-      "integrity": "sha512-WD9sY00OfpHVGfsnHZoA8jVT+esS/Bg8z8jzxp5BnDCjjwsuKsPQrzswwpFy4J1AUJbXPRfkpcX0mXrzeXW79g==",
-      "cpu": [
-        "ia32"
-      ],
+    "node_modules/@unrs/resolver-binding-win32-ia32-msvc": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-ia32-msvc/-/resolver-binding-win32-ia32-msvc-1.12.2.tgz",
+      "integrity": "sha512-WD9sY00OfpHVGfsnHZoA8jVT+esS/Bg8z8jzxp5BnDCjjwsuKsPQrzswwpFy4J1AUJbXPRfkpcX0mXrzeXW79g==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-win32-x64-msvc": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-x64-msvc/-/resolver-binding-win32-x64-msvc-1.12.2.tgz",
+      "integrity": "sha512-nAB74NfSNKknqQ1RrYj6uz8FcXEomu/MATJZxh/x+BArzN2U3JbOYC0APYzUIGhVY3m5hRxA8VPNdPBoG8txlA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@vercel/oidc": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/@vercel/oidc/-/oidc-3.2.0.tgz",
+      "integrity": "sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.10.tgz",
+      "integrity": "sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz",
+      "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.1.10",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.10.tgz",
+      "integrity": "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.10.tgz",
+      "integrity": "sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.1.10",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.10.tgz",
+      "integrity": "sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
     },
-    "node_modules/@unrs/resolver-binding-win32-x64-msvc": {
-      "version": "1.12.2",
-      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-x64-msvc/-/resolver-binding-win32-x64-msvc-1.12.2.tgz",
-      "integrity": "sha512-nAB74NfSNKknqQ1RrYj6uz8FcXEomu/MATJZxh/x+BArzN2U3JbOYC0APYzUIGhVY3m5hRxA8VPNdPBoG8txlA==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@vitest/spy": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.10.tgz",
+      "integrity": "sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
     },
-    "node_modules/@vercel/oidc": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/@vercel/oidc/-/oidc-3.2.0.tgz",
-      "integrity": "sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">= 20"
+    "node_modules/@vitest/utils": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.10.tgz",
+      "integrity": "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.10",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/acorn": {
@@ -2523,6 +3350,17 @@
         "url": "https://github.com/sponsors/epoberezkin"
       }
     },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/ansi-styles": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
@@ -2716,6 +3554,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/ast-types-flow": {
       "version": "0.0.8",
       "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.8.tgz",
@@ -2798,6 +3646,16 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/bidi-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
     "node_modules/brace-expansion": {
       "version": "1.1.15",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz",
@@ -2946,6 +3804,16 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/chai": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -3077,6 +3945,27 @@
         "node": ">= 8"
       }
     },
+    "node_modules/css-tree": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.27.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/css.escape": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
+      "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/csstype": {
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
@@ -3090,6 +3979,20 @@
       "dev": true,
       "license": "BSD-2-Clause"
     },
+    "node_modules/data-urls": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
+      "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
     "node_modules/data-view-buffer": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
@@ -3161,6 +4064,13 @@
         }
       }
     },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/decode-named-character-reference": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
@@ -3262,6 +4172,14 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/dunder-proto": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
@@ -3305,6 +4223,19 @@
         "node": ">=10.13.0"
       }
     },
+    "node_modules/entities": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
+      "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/es-abstract": {
       "version": "1.24.2",
       "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.2.tgz",
@@ -3441,6 +4372,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.1.tgz",
+      "integrity": "sha512-shc1dbU90Yl/xq1QrC7QRtfcwURZuVRfPhZbDoldJ1cn1gzDvBaBWlv0eFolj5+0znnPJz5TXLxsN77X/12KTA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/es-object-atoms": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
@@ -3933,6 +4871,16 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
     "node_modules/esutils": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
@@ -3952,6 +4900,16 @@
         "node": ">=18.0.0"
       }
     },
+    "node_modules/expect-type": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",
+      "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/extend": {
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
@@ -4099,6 +5057,21 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
     "node_modules/function-bind": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
@@ -4485,6 +5458,19 @@
         "node": ">=12.0.0"
       }
     },
+    "node_modules/html-encoding-sniffer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
+      "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.6.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
     "node_modules/html-url-attributes": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.1.tgz",
@@ -4532,6 +5518,16 @@
         "node": ">=0.8.19"
       }
     },
+    "node_modules/indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/inline-style-parser": {
       "version": "0.2.7",
       "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
@@ -4895,6 +5891,13 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/is-regex": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
@@ -5112,6 +6115,57 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
+    "node_modules/jsdom": {
+      "version": "29.1.1",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.1.1.tgz",
+      "integrity": "sha512-ECi4Fi2f7BdJtUKTflYRTiaMxIB0O6zfR1fX0GXpUrf6flp8QIYn1UT20YQqdSOfk2dfkCwS8LAFoJDEppNK5Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^5.1.11",
+        "@asamuzakjp/dom-selector": "^7.1.1",
+        "@bramus/specificity": "^2.4.2",
+        "@csstools/css-syntax-patches-for-csstree": "^1.1.3",
+        "@exodus/bytes": "^1.15.0",
+        "css-tree": "^3.2.1",
+        "data-urls": "^7.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^6.0.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.3.5",
+        "parse5": "^8.0.1",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.1",
+        "undici": "^7.25.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.1",
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.1",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jsdom/node_modules/lru-cache": {
+      "version": "11.5.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz",
+      "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
     "node_modules/jsesc": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
@@ -5578,6 +6632,17 @@
         "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "lz-string": "bin/bin.js"
+      }
+    },
     "node_modules/magic-string": {
       "version": "0.30.21",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
@@ -5890,6 +6955,13 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/mdn-data": {
+      "version": "2.27.1",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
     "node_modules/merge2": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
@@ -6477,6 +7549,16 @@
         "node": ">=8.6"
       }
     },
+    "node_modules/min-indent": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
+      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/minimatch": {
       "version": "3.1.5",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
@@ -6780,6 +7862,20 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/obug": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.4.tgz",
+      "integrity": "sha512-4a+OsYv9UktOJKE+l1A4OufDgdRF9PifWj+tJnHURo/P+WOxpG4GzUFL9qCalmWauao6ogiG+QvnCovwPoyAWA==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -6886,6 +7982,19 @@
       "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
       "license": "MIT"
     },
+    "node_modules/parse5": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^8.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -6913,6 +8022,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -6932,6 +8048,52 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/playwright": {
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.61.1.tgz",
+      "integrity": "sha512-DWnY5o3YbLWK4GovuAVwpqL+1VwGNdUGrRr++8j8PtQQzvAVZUIMjKQ90fY689sEJZJBbZVw1rXaOKSTitkzPQ==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright-core": "1.61.1"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.2"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.61.1.tgz",
+      "integrity": "sha512-h7Qlt6m4REp25qvIdvbDtVmD4LqVXfpRxhORv9L0jzETM05p4fuPJ3dKyuSXQxDSbXnmS79HAgi9589lGSpLkg==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/playwright/node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
     "node_modules/possible-typed-array-names": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
@@ -6943,9 +8105,9 @@
       }
     },
     "node_modules/postcss": {
-      "version": "8.5.16",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.16.tgz",
-      "integrity": "sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==",
+      "version": "8.5.19",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.19.tgz",
+      "integrity": "sha512-Mz8SaolMd8nB+G13WkORcxQKHZ/NE4xXevtkJHVuG+guo9/wYKlIMTKAqGdEmYOXR2ijPjTYNHssizdaVSUNdQ==",
       "dev": true,
       "funding": [
         {
@@ -6981,6 +8143,44 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
+      },
+      "engines": {
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+      }
+    },
+    "node_modules/pretty-format/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/pretty-format/node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/prop-types": {
       "version": "15.8.1",
       "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
@@ -7089,6 +8289,20 @@
         "react": ">=18"
       }
     },
+    "node_modules/redent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
+      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "indent-string": "^4.0.0",
+        "strip-indent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/reflect.getprototypeof": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -7216,6 +8430,16 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/resolve": {
       "version": "2.0.0-next.7",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.7.tgz",
@@ -7271,6 +8495,40 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/rolldown": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.1.5.tgz",
+      "integrity": "sha512-t9z29cJjXf/vxQ8dyhCSpt6H6aSwHTk8cT5I3iy6SMXuFpk5mB6PL6XfC8PCwrPTx93udwKUm9HRteAlTGBLiA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/types": "=0.139.0",
+        "@rolldown/pluginutils": "^1.0.0"
+      },
+      "bin": {
+        "rolldown": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@rolldown/binding-android-arm64": "1.1.5",
+        "@rolldown/binding-darwin-arm64": "1.1.5",
+        "@rolldown/binding-darwin-x64": "1.1.5",
+        "@rolldown/binding-freebsd-x64": "1.1.5",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.1.5",
+        "@rolldown/binding-linux-arm64-gnu": "1.1.5",
+        "@rolldown/binding-linux-arm64-musl": "1.1.5",
+        "@rolldown/binding-linux-ppc64-gnu": "1.1.5",
+        "@rolldown/binding-linux-s390x-gnu": "1.1.5",
+        "@rolldown/binding-linux-x64-gnu": "1.1.5",
+        "@rolldown/binding-linux-x64-musl": "1.1.5",
+        "@rolldown/binding-openharmony-arm64": "1.1.5",
+        "@rolldown/binding-wasm32-wasi": "1.1.5",
+        "@rolldown/binding-win32-arm64-msvc": "1.1.5",
+        "@rolldown/binding-win32-x64-msvc": "1.1.5"
+      }
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -7350,6 +8608,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
     "node_modules/scheduler": {
       "version": "0.27.0",
       "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
@@ -7572,6 +8843,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -7598,6 +8876,20 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.2.0.tgz",
+      "integrity": "sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/stop-iteration-iterator": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
@@ -7750,6 +9042,19 @@
         "node": ">=4"
       }
     },
+    "node_modules/strip-indent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
+      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "min-indent": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -7843,6 +9148,13 @@
         "react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tailwindcss": {
       "version": "4.3.2",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.3.2.tgz",
@@ -7876,6 +9188,23 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz",
+      "integrity": "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/tinyglobby": {
       "version": "0.2.17",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
@@ -7924,6 +9253,36 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/tinyrainbow": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.0.tgz",
+      "integrity": "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tldts": {
+      "version": "7.4.9",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.9.tgz",
+      "integrity": "sha512-3kZ8wQQ/k5DrChD4X4FVvr2D7E5uoRgAqkPyLpSCGUvqOvqu+JEdr3mwMUaVWb+vMHZaKhF5fp2PBigKsui7hA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^7.4.9"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "7.4.9",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.9.tgz",
+      "integrity": "sha512-DxKfPBI52p2msTEu7MPhdpdDTBhhVQg1a/8PjQckeyAvO13eMYElX545grIp6nnTGIMZlRvFZPvFhvI/WIz2Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -7937,6 +9296,32 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/tough-cookie": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",
+      "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^7.0.5"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/trim-lines": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
@@ -8150,6 +9535,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/undici": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.28.0.tgz",
+      "integrity": "sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.18.1"
+      }
+    },
     "node_modules/undici-types": {
       "version": "7.18.2",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
@@ -8374,6 +9769,248 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/vite": {
+      "version": "8.1.5",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.1.5.tgz",
+      "integrity": "sha512-7ULLwsCdYx/nRyrpiEwvqb5TFHrMVZyBt+rg/OAXT7rgj/z+DtTDyKFeLAdDkubDVDKD8jOsndmy7m55XcfUsw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.5",
+        "postcss": "^8.5.17",
+        "rolldown": "~1.1.5",
+        "tinyglobby": "^0.2.17"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.3.0",
+        "esbuild": "^0.27.0 || ^0.28.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/vitest": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.10.tgz",
+      "integrity": "sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.1.10",
+        "@vitest/mocker": "4.1.10",
+        "@vitest/pretty-format": "4.1.10",
+        "@vitest/runner": "4.1.10",
+        "@vitest/snapshot": "4.1.10",
+        "@vitest/spy": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^4.0.0-rc.1",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.1.10",
+        "@vitest/browser-preview": "4.1.10",
+        "@vitest/browser-webdriverio": "4.1.10",
+        "@vitest/coverage-istanbul": "4.1.10",
+        "@vitest/coverage-v8": "4.1.10",
+        "@vitest/ui": "4.1.10",
+        "happy-dom": "*",
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        },
+        "vite": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/picomatch": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+      "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
+      "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",
+      "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.11.0",
+        "tr46": "^6.0.0",
+        "webidl-conversions": "^8.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -8479,6 +10116,23 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/word-wrap": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
@@ -8489,6 +10143,23 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",

frontend/package.json

@@ -8,7 +8,11 @@
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "test": "node --test lib/chat-transport.test.mts",
+    "test": "npm run test:unit && npm run test:components",
+    "test:unit": "node --test lib/*.test.mts",
+    "test:components": "vitest run",
+    "test:e2e": "playwright test",
+    "test:watch": "vitest",
     "lint": "eslint ."
   },
   "dependencies": {
@@ -26,13 +30,19 @@
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
+    "@playwright/test": "^1.61.1",
     "@tailwindcss/postcss": "^4.1.17",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.2",
     "@types/react-dom": "^19.2.2",
     "eslint": "^9.39.4",
     "eslint-config-next": "^16.2.3",
+    "jsdom": "^29.1.1",
     "tailwindcss": "^4.2.2",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
   }
 }

frontend/playwright.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig, devices } from "@playwright/test";
+
+export default defineConfig({
+  testDir: "./e2e",
+  outputDir: "../output/playwright/test-results",
+  fullyParallel: false,
+  forbidOnly: Boolean(process.env.CI),
+  retries: process.env.CI ? 1 : 0,
+  reporter: process.env.CI ? "github" : "list",
+  use: {
+    baseURL: "http://127.0.0.1:3100",
+    screenshot: "only-on-failure",
+    trace: "retain-on-failure",
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] },
+    },
+  ],
+  webServer: {
+    command: "python3 -m http.server 3100 --bind 127.0.0.1 --directory out",
+    url: "http://127.0.0.1:3100",
+    reuseExistingServer: !process.env.CI,
+    timeout: 120_000,
+  },
+});

frontend/test/setup.ts

@@ -0,0 +1,13 @@
+import "@testing-library/jest-dom/vitest";
+
+import { cleanup } from "@testing-library/react";
+import { afterEach, vi } from "vitest";
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+if (!HTMLElement.prototype.scrollIntoView) {
+  HTMLElement.prototype.scrollIntoView = vi.fn();
+}

frontend/vitest.config.ts

@@ -0,0 +1,16 @@
+import { fileURLToPath, URL } from "node:url";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": fileURLToPath(new URL(".", import.meta.url)),
+    },
+  },
+  test: {
+    environment: "jsdom",
+    globals: true,
+    include: ["components/**/*.test.tsx"],
+    setupFiles: ["./test/setup.ts"],
+  },
+});